Magnum One/Magnum One (Mid-American Digital) (Disc Manufacturing).iso/d11/frain14r.arc/FRACTINT.DOC

Text File | 1990-08-12 | 241KB | 5,429 lines

                          Fractint Version 14.0
  CONTENTS

  New Features in Version 14.0

  Introduction

  1. Quick Start: FRACTINT Commands
      Plotting
      Colors
      Saving, Restoring and Printing
      "3D"
      Interrupting and Resuming
      More Zoom Box Commands
      Hints

  2. Fractal Types
       Mandelbrot
       Julia
       Newton's Formula
       Lambda
       MandelLambda
       Plasma Clouds
       LambdaFn
       MandelFn
       Barnsley Mandelbrot/Julia
       Barnsley IFS
       Sierpinski Gasket
       Quartic Mandelbrot/Julia
       Distance Estimator Mandelbrot/Julia
       Pickover Mandelbrot/Julia Types
       Peterson Variations
       Unity
       Scott Taylor /Lee Skinner Variations
       KAM Torus, KAM Torus 3D
       Bifurcation, Biflambda, Bif+sinpi, Bif=sinpi
       Lorenz, Lorenz3d
       Rossler
       Henon
       Pickover
       Gingerbreadman
       Test Stub
       Formula
       Julibrots
       Diffusion
       Magnet1m, Magnet1j, Magnet2m, Magnet2j

      Doodads, Bells and Whistles
       "3D" Images
       Distance Estimator Method
       Inversion
       Decomposition
       Starmaps
       Logarithmic Palettes
       Pickover Biomorphs and Popcorn


                                       1


  3. Command-Line Arguments, Batch Mode, and SSTOOLS.INI

  4. File Formats, Colors, and All That
      .FRA and .GIF Files
      Continuous Potential
      Palette Maps

  5. Hardware Support
      Notes on Modes, "Standard" and Otherwise
      FRACTINT.CFG

  6. Fractals and the PC
      A Little History
       B.M. (Before Mandelbrot)
       Who Is This Guy, Anyway?
      A Little Code
       Logic Speed-ups
       The Limitations of Integer Math
       The Fractint "Fractal Engine" Architecture

  Appendix A: Mathematics of the Fractal Types
  Appendix B: Stone Soup with Pixels
  Appendix C: Revision History
  Appendix D: Bibliography
  Appendix E: Other Recommended Fractal Programs
  Appendix F: Version 13 to Version 14 Type Mapping






























                                       2

  NEW FEATURES IN VERSION 14.0

  LAST MINUTE NEWS FLASH!
    Compuserve announces the GIF89a on August 1, 1990, and FRACTINT
    supports it on August 2! GIF files can now contain fractal
    information!  FRACTINT now saves its files in the new GIF89a format
    by default, and uses .GIF rather than .FRA as a default filetype.
    Note that FRACTINT still *looks* for a .FRA file on file restores
    if it can't find a .GIF file, and can be coerced into using the old
    GIF87a format with the new 'gif87a=yes' command-line option.

  Pieter Branderhorst mounted a major campaign to get his name in lights:
  Mouse interface:  Diagonals, faster movement, improved feel.
    Mouse button assignments have changed - see the online help.
  Zoom box enhancements:  The zoom box can be rotated, stretched, skewed,
    and panned partially offscreen.  See "More Zoom Box Commands".
  FINALLY!! You asked for it and we (eventually, by talking Pieter into
    it [actually he grabbed it]) did it!  Images can be saved before
    completion, for a subsequent restore and continue.  See "Interrupting
    and Resuming" and "Batch Mode".
  Off-center symmetry:  Fractint now takes advantage of x or y axis
    symmetry anywhere on the screen to reduce drawing time.
  Panning:  If you move an image up, down, left, or right, and don't
    change anything else, only the new edges are calculated.
  Disk-video caching - it is now possible, reasonable even, to do most
    things with disk video, including solid guessing, 3d, and plasma.
  Logarithmic palette changed to use all colors.  It now matches regular
     palette except near the "lake".  "logmap=old" gets the old way.
  New "savetime=nnn" parameter to save checkpoints during long calculations.
      Calculation time is shown in <Tab> display.

  Kevin Allen, of Antipodean origin, did the following:
  Made Bifurcation/Verhulst into a generalised Fractal Engine (like
      StandardFractal, but for Bifurcation types), and implemented
      periodicity checking for Bifurcation types to speed them up.
  Added Integer version of Verhulst Bifurcation (lots faster now).
      Integer is the default.  The Floating-Point toggle works, too.
  Added NEW Fractal types BIFLAMBDA, BIF+SINPI, and BIF=SINPI.
      These are Bifurcation types that make use of the new Engine.
      Floating-point/Integer toggle is available for BIFLAMBDA.
      The SINPI types are Floating-Point only, at this time.
  Corrected the generation of the MandelLambda Set.  Sorry, but it's
      always been wrong (up to v 12, at least).  Ask Mandelbrot !
  Added NEW Fractal types MAGNET1M, MAGNET1J, MAGNET2M, MAGNET2J from
      "The Beauty of Fractals".  Floating-Point only, so far, but
      what do you expect with THESE formulae ?!
  Added new symmetry types XAXIS NOIMAG and XAXIS NOREAL, required by
      the new MAGNETic Fractal types.
  Added Finite Attractor Bailout (FAB) logic to detect when
      iterations are approaching a known finite attractor. This is
      required by the new MAGNETic Fractal types.
  Added Finite Attractor Detection (FAD) logic which can be used by
      *SOME* Julia types prior to generating an image, to test for
      finite attractors, and find their values, for use by FAB logic.
      Can be used by the new MAGNETic Fractal Types, Lambda Sets, and
      some other other Julia types too.

                                       3

  Mike Burkey sent us new tweaked video modes:
    VGA     - 400x600x256   376x564x256   400x564x256
    ATI VGA - 832x612x256

  New HP Paintjet support from Chris Martin
  New "FUNCTION=" command to allow substition of different transcendental
     functions for variables in types (allows one type with four of these
     variables to represent 7*7*7*7 different types!

  ALL KINDS of new fractal types, some using "FUNCTION=": fn(z*z), fn*fn,
     fn*z+z, fn+fn, sqr(1/fn), sqr(fn), spider, tetrate, and Manowar. Most
     of these are generalizations of formula fractal types contributed by
     Scott Taylor and Lee Skinner.
  Distance Estimator logic can now be applied to many fractal types using
    distest= option. The types "demm" and "demj" have been replaced by
    "type=mandel distest=nnn" and "type=julia distest=nnn"
  Added extended memory support for diskvideo thanks to Paul Varner
  Added support for "center and magnification" format for corners.
  Color 0 is no longer generated except when specifically requested with
    inside= or outside=.
  Formula name is now included in <Tab> display and in <S>aved images.
  Bug fixes - formula type and diskvideo, batch file outside=-1 problem
  Now you can produce your favorite fractal terrains in full color instead of
     boring old monochrome! Use the fullcolor option in 3d! Along with a
     few new 3D options.
  New "INITORBIT=" command to allow alternate Mandelbrot set orbit
     initialization.






























                                       4

  INTRODUCTION

  FRACTINT plots and manipulates images of "objects" -- actually, sets of
  mathematical points -- that have fractal dimension. See chapter 6 for
  some historical and mathematical background on fractal geometry, a
  discipline named and popularized by mathematician Benoit Mandelbrot.
  For now, these sets of points have three important properties:

  1) They are generated by relatively simple calculations repeated over
  and over, feeding the results of each step back into the next --
  something computers can do very rapidly.

  2) They are, quite literally, infinitely complex: they reveal more and
  more detail without limit as you plot smaller and smaller areas.
  FRACTINT lets you "zoom in" by positioning a small box and hitting
  <Enter> to redraw the boxed area at full-screen size; its maximum
  linear "magnification" is over a trillionfold.

  3) They can be astonishingly beautiful, especially using PC color
  displays' ability to assign colors to selected points, and (with VGA
  displays or EGA in 640x350x16 mode) to "animate" the images by quickly
  shifting those color assignments.

  The name FRACTINT was chosen because the program generates many of its
  images using INTeger math, rather than the floating-point calculations
  used by most such programs. That means that you don't need a math co-
  processor chip (aka floating-point unit or FPU), although for a few
  fractal types where floating-point math is faster, the program recog-
  nizes and automatically uses an 80x87 chip if it's present. It's even
  faster on systems using Intel's 80386 and 80486 microprocessors, where
  the integer math can be executed in their native 32-bit mode.

  FRACTINT works with many adapters and graphics modes from CGA to the
  1024x768, 256-color 8514/A mode. Even "larger" images, up to
  2048x2048x256, can be plotted to expanded memory, extended memory, or
  disk: this bypasses the screen and allows you to create images with
  higher resolution than your current display can handle, and to run in
  "background" under multi-tasking control programs such as DESQview and
  Windows 3.

  FRACTINT is an experiment in collaboration. Many volunteers have joined
  Bert Tyler, the program's first author, in improving successive ver-
  sions. Through electronic-mail messages, first on CompuServe's PICS forum
  and now on COMART, new versions are hacked out and debugged a little
  at a time. FRACTINT was born fast, and none of us has seen any other
  fractal plotter close to the present version for speed, versatility, and
  all-around wonderfulness. (If you have, tell us so we can steal somebody
  else's ideas instead of each other's.) See Appendix B for information
  about the authors and how to contribute your own ideas and code.








                                       5

  The executable FRACTINT.EXE is public domain, and we encourage you to
  share copies and upload it to bulletin-board systems. Except for those
  modules marked with a copyright notice (and subject to the authors'
  conditions in the notices), the source code is also public domain.
  There is no warranty of its suitability for any purpose, nor any
  acceptance of liability, express or implied.

  Contribution policy: Don't want money. Got money. Want admiration.

















































                                       6

  1. QUICK START: FRACTINT Commands

  To start the program, enter FRACTINT at the DOS prompt. The program
  displays an initial "credits" screen, and waits for you to hit a
  command key that will (1) start plotting in a specific video mode or
  (2) set one of many options. You can also (at this screen or at any
  time) press the HELP key (F1) for screens describing the commands and
  video modes. As soon as you select a video mode, the program begins
  drawing an initial display -- the "full" Mandelbrot set, if you haven't
  selected another fractal type. From this point on, and AT ANY TIME, you
  can hit any of the following keys to select a function. (For the
  "typewriter" keys, upper and lower case are equivalent: <B> and <b>,
  have the same result.)

  Many commands and parameters can be passed to FRACTINT.EXE as command-
  line arguments or read from a configuration file; see Sec. 3 for
  details.

                        Plotting Commands

  <F1>
  Bring up a help screen. The Escape key brings you back.

  Function keys & various combinations (see help screens) are used to
  select a video mode and redraw the screen.  For a quick start, try one
  of the following:
    If you have MCGA, VGA, or better:  <F3>
    If you have EGA:                   <F9>
    If you have CGA:                   <F5>
    Otherwise, monochrome:             <F6>
  Remember to look through the help screens later for additional modes.

  <Page Up>
  Display and shrink the zoom box ("zoom in"). The LEFT button of a mouse
  displays the box; push the mouse away from you while holding that
  button down to shrink the box.

  <Page Down>
  Display and expand the zoom box ("zoom out"). Pulling the mouse towards
  you with the left button down has the same effect.

  Cursor ("arrow") keys
  Move ("pan") the zoom box. Moving the mouse has the same effect. With
  an enhanced-keyboard BIOS, <Ctrl> plus a cursor key moves the box 5
  times faster.

  <Enter> ("Return") or <End>
  Redraw the area inside the zoom box as a full-screen image. Or double
  click the left mouse button.  If there's no zoom box on the screen,
  and the current image is incomplete (e.g. if you interrupted it to adjust
  the colors) <Enter> resumes calculating the image.  If the image was
  complete or you've changed some options, <Enter> clears the screen and
  redraws.




                                       7

  <Ctrl><Enter>
  "Zoom out," so that your screen would fill the current zoom box, and
  redraw.  Or double click the right mouse button.

  <Esc> or <Delete>
  Exit FRACTINT and return to DOS.

  <Home>
  Redraw the previous image. The program tracks 25 sets of coordinates.

  <Tab>
  Display the current fractal type, parameters, screen or (if displayed)
  zoom-box coordinates, maximum iteration count, and other information
  useful in keeping track of where you are.  The Tab function is
  non-destructive - if you press it while in the midst of generating an
  image, you will continue generating it when you return.  The Tab
  function tells you if your image is still being generated or has
  finished - a handy feature for those overnight, 1024x768 resolution
  fractal images.  If the image is incomplete, it now also tells you
  whether it can be interrupted and resumed.

  <T>
  Select a fractal type. Move the cursor to your choice and hit <Enter>.
  You will be prompted for any parameters that type may require.

  <X>
  Select any number of eXtended options. Brings up a full-screen menu of
  options, any number of which you can change at will.  This list currently
  includes the F(loating point algorithm) toggle, the image generation
  algorithm (passes = 1, 2, solid-guessing, or boundary tracing), the
  "maxiter=" iteration maximum, the "inside=" and "outside=" colors, the
  Logarithmic Palettes option, the Biomorph and Decomposition
  algorithms, the "sound=" option, "warn=" option, "bailout=" value, the
  "distest=" value, and the "potential=" parameters.

  <1>, <2>, or <G>
  Select single-pass, dual-pass, or solid-guessing (default) mode, then
  redraw the screen. Single-pass mode draws the screen pixel by pixel.
  Dual-pass generates a "coarse" screen first as a preview using 2x2-
  pixel boxes, and then generates the rest of the dots with a second
  pass. Solid-guessing performs from two to four visible passes - more
  passes in higher resolution video modes. Its first visible pass is
  actually two passes - one pixel per 4x4, 8x8, or 16x16 pixel box
  (depending on number of passes) is generated, and the guessing logic
  is applied to fill in the blocks at the next level (2x2, 4x4, or 8x8).
  Subsequent passes fill in the display at the next finer resolution,
  skipping blocks which are surrounded by the same color. Solid-guessing
  can guess wrong, but it sure guesses quickly!  Note: these options,
  along with the Boundary-Tracing alternative, can now also be selected
  using the "X" options screen.  Boundary Tracing, which only works
  with fractal types (such as the Mandelbrot set, but not the Newton
  type) that do not contain "islands" of colors, finds a color "boundary",
  traces it around the screen, and then "blits" in the color over the
  enclosed area.



                                       8

  <Spacebar>
  Toggle between Mandelbrot-set images and their corresponding Julia-set
  images. Read the notes in Sec. 2 before trying this option if you want
  to see anything interesting.

  <B>
  Create a batch file, FRABATCH.BAT, that will start FRACTINT with the
  command-line arguments needed to draw the current image. If
  FRABATCH.BAT already exists, a new line is appended to it.

  < or >
  Lower or raise the maximum iteration count (the number of times the
  program carries out its basic calculation before assigning colors). See
  Sec. 2.  (Note: the maximum iteration count can now also be selected
  explicitly using the "X" options screen.)

  <F>
  Toggles the use of floating-point algorithms. Their use is shown on the
  <Tab> status screen.   (Note: the floating point algorithms option can
  now also be turned on and off using the "X" options screen.)

  <E>
  Call up an editor that modifies, saves and restores various parameters.
  Currently you can change the coefficients used in plotting the Barnsley
  IFS fractal types or the 3D transformations used with the "Lorenz3D"
  and "IFS3D" fractal types, including the selection of "funny glasses"
  red/blue 3D.

  <I>
  Apply the inversion process (Sec. 3) and redraw the screen. Not appli-
  cable to all fractal types.

  <N> or <L>
  Select normal (the default) or logarithmic palette mapping and redraw
  the screen. (See Sec. 3 for details.)   (Note: the Logarithmic palette
  option can now also be turned on and off using the "X" options screen.)

  <Q>
  Apply the quaternary or binary decomposition coloring scheme (see Sec.
  3) and redraw the screen. Not applicable to all fractal types.
  (Note that the decomposition scheme can now select 8, 16, 32, 64, 128,
  and 256-way decomposition, but we're stuck with <Q> for Quaternary.)
  (Note: the Decomposition option can now also be turned on and off
  using the "X" options screen.)

  <O> (the letter, not the number)
  If pressed while an image is being generated, toggle the display of
  intermediate results -- the "orbits" FRACTINT uses as it calculates values
  for each point. Slows the display a bit, but shows you how clever the
  program is being behind the scenes. (See "A Little Code" in Sec. 6.)

  <Insert>
  Restart at the "credits" screen




                                       9

  <D>
  Shell to DOS. Return to FRACTINT by entering "exit" at a DOS prompt.


                         Color Commands

  The color-cycling commands are available ONLY for VGA adapters and EGA
  adapters in 640x350x16 mode. Some keys have different functions specif-
  ic to this mode.

  Note that the palette colors available on an EGA adapter (16 colors at
  a time out of a palette of 64) are limited compared to those of VGA,
  super-VGA, and MCGA (16 or 256 colors at a time out of a palette of
  262,144). So color-cycling in general looks a LOT better in the latter
  modes. Also, because of the EGA palette restrictions, some commands are
  not available with EGA adapters.

  <+> or <->
  Switch to color-command mode and begin cycling the palette by shifting
  each color to the next "contour."

  <C>
  Switch to color-command mode but do not start cycling. The normally
  black "overscan" border of the screen changes to white as a reminder
  that you are in this command mode.

  The rest of the color commands are available only when you've already
  switched to color-command mode.

  <F1>
  Bring up a HELP screen with commands specific to color command mode.
  ESCAPE exits.

  <+> or cursor->, <-> or cursor<-
  Reverse the cycling direction "out" or "in."

  Cursor up/down
  Increase/decrease the cycling speed. High speeds may cause a harmless
  flicker at the top of the screen.

  <F2> through <F10>
  Switches from simple rotation to color selection using randomly-gener-
  ated color bands of short (F2) to long (F10) duration.

  <1> through <9>
  Causes the screen to be updated every 'n' color cycles (the default is
  1). Handy for slower computers.

  <Enter>
  Randomly selects a function key (F2 through F10) and then updates ALL
  the screen colors prior to displaying them for instant, random colors.
  Hit this over and over again (we do).





                                       10

  <Spacebar>
  Pause cycling with white overscan area. Cycling restarts with any
  command key (including another spacebar) -- or you can use any non-
  command key to exit color-command mode so you can (S)ave the image.

  <Shift><F1>-<F10>
  Pause cycling and reset the palette to a preset two-color "straight"
  assignment, such as a spread from black to white. (Not for EGA)

  <Ctrl><F1>-<F10>
  Pause and use a two-color cyclical assignment, e.g. red->yellow->red
  (not for EGA).

  <Alt><F1>-<F10>
  Pause and use a 3-color cyclical assignment, e.g. green->white->blue
  (not for EGA).

  <R>, <G>, <B>
  Pause and increase the red, green, or blue component of all colors by a
  small amount (not for EGA). Note the case distinction of this vs:

  <r>, <g>, <b>
  Pause and decrease the red, green, or blue component of all colors by a
  small amount (not for EGA).

  <D> or <A>
  Pause and load an external color map from the files DEFAULT.MAP or
  ALTERN.MAP, supplied with the program.

  <M>
  Pause and prompt for the filename of an external color map. Several
  others are supplied with the program. (The .MAP extension is assumed;
  see Sec. 4 for details on creating your own map files.)

  <S>
  Pause, prompt for a filename, and save the current palette to the named
  file (.MAP assumed).

  <X>
  Enters the "Cross-Hair" Palette manipulation sub-mode, described below,
  in which you can modify your image one color (palette) at a time
  (not for EGA).

  Any other key terminates the color-cycling process (you can always
  return to it with another <C>, <+> or <->) and returns to the main
  command mode.

               Cross-Hair Mode (a Sub-Mode of Color-Cycling)

  This mode is entered from the main color-cycling mode by pressing the
  "X" key, which brings up a "Cross-Hair" cursor with which you point
  to a pixel using the particular color palette you wish to modify.
  Unlike the main color-cycling level, where you are modifying all of the
  colors at once, Cross-Hair mode modifies only one palette at a time.
  This feature is currently available only on VGA adapters.


                                       11


  <Cursor ("arrow") Keys>
  Move the cross-hair cursor around the screen.  The Control-Cursor keys
  move the cursor around faster.  A mouse can also be used to move around.
  The palette value of the pixel in the middle of your cross-hair cursor
  is the palette value that you will be manipulating.

  <R>, <G>, <B>
  Increase the red, green, or blue component of your palette color by a
  small amount. Note the case distinction of this vs:

  <r>, <g>, <b>
  Decrease the red, green, or blue component of your palette color by a
  small amount.

  <+>, <->
  Changes the RGB components of the palette you are pointing at to those
  of the next higher (or lower, for the <-> key) palette value.  Useful for
  "erasing" bands of color.

  <Ctrl><Insert>, <Ctrl><Delete>
  Change the palette value of the cross-hair cursor to the next higher (or
  lower) palette value.  A handy feature when the cross-hair cursor gets
  "lost" in the background.  Holding down the right mouse button and moving
  the mouse forward and backward has the same effect.

  <Enter>, <Ctrl><Enter>, <Page Up>, <Page Down>
  <Ctrl><Page up>, <Ctrl><Page Down>, <Ctrl><Home>, <Ctrl><End>,
  <Ctrl><Keypad->, <Ctrl><Keypad+>
  Do nothing at all.  Added only to prevent you from accidentally exiting
  cross-hair mode by pressing unassigned mouse buttons.

  Any other key terminates Cross-Hair sub-mode and returns to the main
  Color-Cycling command mode.


                        Save/Restore/Print Commands

  <S>
  Save the screen contents to disk. Progress is marked by colored lines
  moving down the screen's edges. The default filename is FRACT001.GIF;
  multiple saves in a session are automatically incremented 002, 003... If
  you have files left over from previous sessions and want the program to
  keep incrementing rather than starting at 001 again and overwriting, see
  Sec. 3 for the "WARN=yes" argument (or set it with the "X" option screen).

  <R>
  Restore an image previously saved with <S>. You are prompted for the
  filename, .GIF assumed.

  <P>
  Print the current fractal image on your (Laserjet, Paintjet, or
  Epson-compatible) printer. See Sec. 3 for how to let FRACTINT know
  about your printer setup. "Disk video" modes can be used to generate
  images for printing at higher resolutions than your screen supports.


                                       12

                          "3D" Commands

  <3>
  Restore a saved image as a 3D "landscape", translating its color
  information into "height". You will be prompted for all KINDS of
  options; see "3D Images" in Sec. 3 for details.

  <O>
  Restore in 3D and overlay the result on the current screen. (This
  only works when there's a completed on screen, so it can't be
  confused with the <O>-for-orbits toggle that ONLY operates WHILE a
  fractal is being generated.)


                     Interrupting and Resuming

  Fractint command keys can be loosely grouped as:

    o Keys which suspend calculation of the current image (if one is
      being calculated) and automatically resume after the function.
      <Tab> (display status information) and <F1> (display help), are
      the only keys in this group.

    o Keys which automatically trigger calculation of a new image.
      Examples:  selecting a video mode (e.g. <F3>);  selecting a fractal
      type using <T>;  changing the floating point toggle using <F>.

    o Keys which do something, then wait for you to indicate what to do
      next.  Examples:  <C> to enter color command mode;  <PageUp> to
      bring up a zoom box;  <S> to save an image.  After using a command
      in this group, you can resume calculation of the interrupted image
      with the <Enter> key.  Most but not all fractal types are resumable
      in this fashion.  If you've changed any option which can result in
      a different image, <Enter> will start a new image instead of
      resuming.

  An image which is <S>aved before it completes can later be <R>estored
  and then resumed by hitting <Enter>.

  When <Enter> is used to resume a slow fractal type, there may be a lag
  while nothing visible happens.  This is because most cases of resume
  re-start at the beginning of a screen line.  If unsure, you can check
  whether calculation has resumed with the <Tab> key.

  The following fractal types cannot (currently) be resumed: plasma,
  julibrot, any type with a continuous potential output file, and 3d
  orbital types like lorenz3d.  To check whether resuming an image is
  possible, use the <Tab> key while it is calculating.  It is resumable
  unless there is a note under the fractal type saying it is not.

  The "Batch Mode" section discusses how to resume in batch mode.

  If you <R>estore a "formula" type fractal (described later) and want to
  resume it, your "formulafile" must contain the required formula.



                                       13


                       More Zoom Box commands

  In addition to resizing the zoom box and moving it around, you can do
  some rather warped things with it. The general approach is always the
  same: Frame an area, then <Enter> to expand what's in the frame to fill
  the whole screen (zoom in); or <Ctrl><Enter> to shrink the current image
  into the framed area (zoom out). With a mouse, double-click the left
  button to zoom in, double click the right button to zoom out.

  <Page Up>, <Page Down>
  Use <Page Up> to initially bring up the zoom box. It starts at full
  screen size. Subsequent use of these keys makes the zoom box smaller or
  larger. Using <Page Down> to enlarge the zoom box when it is already at
  maximum size removes the zoom box from the display. Moving the mouse
  away from you or toward you while holding the left button down performs
  the same functions as these keys.

  The cursor "arrow" keys, holding <Ctrl> with the "arrow" keys, and
  moving the mouse without holding any buttons down, moves the zoom box.

  Panning: If you move a fullsize zoombox and don't change anything else
  before performing the zoom, Fractint just moves what's already on the
  screen and then fills in the new edges, to reduce drawing time.  This
  feature applies to most fractal types but not all.  A side effect is
  that while an image is incomplete, a full size zoom box moves in steps
  larger than one pixel.  Fractint keeps the box on multiple pixel
  boundaries, to make panning possible.  As a multi-pass (e.g. solid
  guessing) image approaches completion, the zoom box can move in smaller
  increments.

  <Ctrl><Keypad->, <Ctrl><Keypad+>
  Holding <Ctrl> and pressing the numeric keypad's + or - keys rotates
  the zoom box. Moving the mouse left or right while holding the right
  button down performs the same function.

  <Ctrl><Page Up>, <Ctrl><Page Down>
  These commands change the zoom box's "aspect ratio", stretching or
  shrinking it vertically. Moving the mouse away from you or toward you
  while holding both buttons (or the middle button on a 3-button mouse)
  down performs the same function. There are no commands to directly
  stretch or shrink the zoom box horizontally - the same effect can be
  achieved by combining vertical stretching and resizing.

  <Ctrl><Home>, <Ctrl><End>
  These commands "skew" the zoom box, moving the top and bottom edges in
  opposite directions. Moving the mouse left or right while holding both
  buttons (or the middle button on a 3-button mouse) down performs the
  same function. There are no commands to directly skew the left and
  right edges - the same effect can be achieved by using these functions
  combined with rotation.

  <Ctrl><Insert>, <Ctrl><Delete>
  These commands change the zoom box color. This is useful when you're
  having trouble seeing the zoom box against the colors around it. Moving


                                       14

  the mouse away from you or toward you while holding the right button
  down performs the same function.

  You may find it difficult to figure out what combination of size,
  position, rotation, stretch, and skew to use to get a particular result.
  (We do.) A good way to get a feel for all these functions is to play
  with the Gingerbreadman fractal type. Gingerbreadman's shape makes it
  easy to see what you're doing to him. A warning though: Gingerbreadman
  will run forever, he's never quite done! So, pre-empt with your next
  zoom when he's baked enough.

  If you accidentally change the shape of your zoom box, or rotate and
  forget which way is up, just use <Page Down> to make it bigger until
  it is removed from the display, then <Page Up> to get a fresh one.
  With the mouse, after removing the old zoom box from the display,
  release and re-press the left button to get a fresh one.

  If your screen does not have a 4:3 "aspect ratio" (i.e. if the visible
  display area on it is not 1.333 times as wide as it is high), rotating
  and zooming will have some odd effects - angles will change, including
  the zoom box's shape itself, circles (if you are so lucky as to see
  any with a non-standard aspect ratio) become non-circular, and so on.
  The vast majority of PC screens *do* have a 4:3 aspect ratio.

  Zooming is not implemented for the plasma and diffusion fractal types,
  nor for <O>verlayed and <3>d images. A few fractal types support zooming
  but do not support rotation and skewing - nothing happens when you try it.


                                HINTS

  Remember, you do NOT have to wait for the program to finish a full
  screen display before entering a command. If you see an interesting
  spot you want to zoom in on while the screen is half-done, don't wait -
  - do it! If you think after seeing the first few lines that another
  video mode would look better, go ahead -- FRACTINT will shift modes and
  start the re-draw at once. When it finishes a display, it beeps and
  waits for your next command.

  In general, the most interesting areas are the "border" areas where the
  colors are changing rapidly. Zoom in on them for the best results. The
  first Mandelbrot-set (default) fractal image has a large, solid-colored
  interior that is the slowest to display; there's nothing to be seen by
  zooming there.

  Plotting time is directly proportional to the number of pixels in a
  screen, and hence increases with the resolution of the video mode.
  After you get used to the first "zoom levels," you may want to start in
  a low-resolution mode for quick progress, and switch to a higher-
  resolution mode when things get interesting. Or use the <G>uessing mode
  and pre-empt with a zoom before it finishes. Plotting time also varies
  with the maximum iteration setting, the fractal type, and your choice
  of drawing mode. Solid-guessing (the default) is fastest, but it can be
  wrong: perfectionists will want to use dual-pass mode (its first-pass
  preview is handy if you might zoom pre-emptively) or single-pass mode.


                                       15


  When you start systematically exploring, you can save time (and hey,
  every little bit helps -- these "objects" are INFINITE, remember!) by
  <S>aving your last screen in a session to a file, and then going
  straight to it the next time with FRACTINT FRACTxxx (the .GIF
  extension is assumed). Or you could simply hit <B> to create a batch
  file with the "recipe" for a given image, and next time start with
  FRABATCH to re-plot it. See Sec. 4 for more on batch mode and the
  command-line arguments the <B> command writes.
















































                                       16

  2. FRACTAL TYPES

  This section is intended only as a quick introduction to the types;
  more detail on the mathematics of types other than the Mandelbrot set
  can be found in Appendix A, and some notes on how FRACTINT calculates
  them in Sec. 6.

  FRACTINT starts by default with the Mandelbrot set. You can change that
  by firing it up with the command-line argument "TYPE=" followed by one
  of the names in parentheses below, or within the program by hitting <T>
  and typing in the name. If parameters are needed, you will be prompted
  for them.

  In the text that follows, due to the limitations of the ASCII character
  set, "a*b" means "a times b", and "a^b" means "a to the power b".


  THE MANDELBROT SET (type=mandel)

  This set is the classic: the only one implemented in many plotting
  programs, and the source of most of the printed fractal images pub-
  lished in recent years. Like most of the other types in FRACTINT, it is
  simply a graph: the x (horizontal) and y (vertical) coordinate axes
  represent ranges of two independent quantities, with various colors
  used to symbolize levels of a third quantity which depends on the first
  two. So far, so good: basic analytic geometry.

  Now things get a bit hairier. The x axis is ordinary, vanilla real
  numbers. The y axis is an imaginary number, i.e. a real number times i,
  where i is the square root of -1. Every point on the plane -- in this
  case, your PC's display screen -- represents a complex number of the
  form:

  x-coordinate + i * y-coordinate

  If your math training stopped before you got to imaginary and complex
  numbers, this is not the place to catch up. Suffice it to say that they
  are just as "real" as the numbers you count fingers with (they're used
  every day by electrical engineers) and they can undergo the same kinds
  of algebraic operations.

  OK, now pick any complex number -- any point on the complex plane --
  and call it C, a constant. Pick another, this time one which can vary,
  and call it Z. Starting with Z=0 (i.e., at the origin, where the real
  and imaginary axes cross), calculate the value of the expression

  Z^2 + C

  Take the result, make it the new value of the variable Z, and calculate
  again. Take that result, make it Z, and do it again, and so on: in
  mathematical terms, iterate the function Z(n+1) = Z(n)^2 + C. For
  certain values of C, the result "levels off" after a while. For all
  others, it grows without limit. The Mandelbrot set you see at the start
  -- the solid-colored lake (blue by default), the blue circles sprouting
  from it, and indeed every point of that color -- is the set of all


                                       17

  points C for which the value of Z is less than 2 after 150 iterations
  (default setting). All the surrounding "contours" of other colors
  represent points for which Z exceeds 2 after 149 iterations (the
  contour closest to the M-set itself), 148 iterations, (the next one
  out), and so on.

  Some features of interest:

  1. Use the > key or the <X> options screen to increase the number of
  iterations. Notice that the boundary of the M-set becomes more and more
  convoluted (the technical terms are "wiggly," "squiggly," and "utterly
  bizarre") as the Z-values for points that were still within the set
  after 150 iterations turn out to exceed 2 after 200, 500, or 1200.
  In fact, it can be proven that the true boundary is infinitely long:
  detail without limit.

  2. Although there appear to be isolated "islands" of blue, zoom in --
  that is, plot for a smaller range of coordinates to show more detail --
  and you'll see that there are fine "causeways" of blue connecting them
  to the main set. As you zoomed, smaller islands became visible; the
  same is true for them. In fact, there are no isolated points in the M-
  set: it is "connected" in a strict mathematical sense.

  3. The upper and lower halves of the first image are symmetric (a fact
  that FRACTINT makes use of here and in some other fractal types to
  speed plotting). But notice that the same general features --lobed
  discs, spirals, starbursts -- tend to repeat themselves
  (although never exactly) at smaller and smaller scales, so that it can
  be impossible to judge by eye the scale of a given image.

  4. In a sense, the contour colors are window-dressing: mathematically,
  it is the properties of the M-set itself that are interesting, and no
  information about it would be lost if all points outside the set were
  assigned the same color. If you're a serious, no-nonsense type, you may
  want to cycle the colors just once to see the kind of silliness that
  other people enjoy, and then never do it again. Go ahead. Just once,
  now. We trust you.


  JULIA SETS (type=julia)

  These sets were named for mathematician Gaston Julia, and can be
  generated by a simple change in the iteration process described above.
  Start with a specified value of C, "C-real + i * C-imaginary"; use as
  the initial value of Z "x-coordinate + i * y-coordinate"; and repeat
  the same iteration, Z(n+1) = Z(n)^2 + C.

  There is a Julia set corresponding to every point on the complex
  plane -- an infinite number of Julia sets. But the most visually
  interesting tend to be found for the same C values where the M-set
  image is busiest, i.e. points just outside the boundary. Go too far
  inside, and the corresponding Julia set is a circle; go too far out-
  side, and it breaks up into scattered points. In fact, all Julia sets
  for C within the M-set share the "connected" property of the M-set, and
  all those for C outside lack it.


                                       18

  FRACTINT's spacebar toggle lets you "flip" between any view of the M-set
  and the Julia set for the point C at the center of that screen. You can
  then toggle back, or zoom your way into the Julia set for a while and then
  return to the M-set. So if the infinite complexity of the M-set palls,
  remember: each of its infinite points opens up a whole new Julia set.

  Historically, the Julia sets came first: it was while looking at the M-
  set as an "index" of all the Julia sets' origins that Mandelbrot
  noticed its properties.

  The relationship between the Mandelbrot set and Julia set can hold
  between other sets as well.  Many of FRACTINT's types are
  "Mandelbrot/Julia" pairs (sometimes called "M-sets" or "J-sets". All
  these are generated by equations that are of the form z(k+1) =
  f(z(k),c), where the function orbit is the sequence z(0), z(1), ..., and
  the variable c is a complex parameter of the equation. The value c is
  fixed for "Julia" sets and is equal to the first two parameters entered
  with the "params=Creal/Cimag" command. The initial orbit value z(0) is
  the complex number corresponding to the screen pixel. For Mandelbrot
  sets, the parameter c is the complex number corresponding to the screen
  pixel. The value z(0) is c plus a perturbation equal to the values of
  the first two parameters.  See discussion of "type=mandellambda" this
  approach may or may not be the "standard" way to create "Mandelbrot"
  sets out of "Julia" sets.

  Some equations have additional parameters.  These values is entered as the
  third for fourth params= value for both Julia and Mandelbrot sets. The
  variables x and y refer to the real and imaginary parts of z; similarly,
  cx and cy are the real and imaginary parts of the parameter c and fx(z)
  and fy(z) are the real and imaginary parts of f(z). The variable c is
  sometimes called lambda for historical reasons.

  NOTE: if you use the "PARAMS=" argument to warp the M-set by starting
  with an initial value of Z other than 0, the M-set/J-sets correspon-
  dence breaks down and the spacebar toggle no longer works.


  NEWTON DOMAINS OF ATTRACTION (type=newtbasin)

  The Newton formula is an algorithm used to find the roots of polynomial
  equations by successive "guesses" that converge on the correct value as
  you feed the results of each approximation back into the formula. It
  works very well -- unless you are unlucky enough to pick a value that
  is on a line BETWEEN two actual roots. In that case, the sequence
  explodes into chaos, with results that diverge more and more wildly as
  you continue the iteration.

  This fractal type shows the results for the polynomial Z^n - 1, which
  has n roots in the complex plane. Use the <T>ype command and enter
  "newtbasin" in response to the prompt. You will be asked for a parame-
  ter, the "order" of the equation (an integer from 3 through 10 -- 3 for
  x^3 - 1, 7 for x^7-1, etc.). A second parameter is a flag to turn on
  alternating shades showing changes in the number of iterations needed to
  attract an orbit. Some people like stripes and some don't, as always,
  FRACTINT gives you a choice!


                                       19


  The coloring of the plot shows the "basins of attraction" for each root
  of the polynomial -- i.e., an initial guess within any area of a given
  color would lead you to one of the roots. As you can see, things get a
  bit weird along certain radial lines or "spokes," those being the lines
  between actual roots. By "weird," we mean infinitely complex in the good
  old fractal sense. Zoom in and see for yourself.

  This fractal type is symmetric about the origin, with the number of
  "spokes" depending on the order you select. It uses floating-point math
  if you have an FPU, or a somewhat slower integer algorithm if you don't
  have one.


  NEWTON (type=newton)

  The generating formula here is identical to that for newtbasin, but the
  coloring scheme is different. Pixels are colored not according to the
  root that would be "converged on" if you started using Newton's formula
  from that point, but according to the iteration when the value is close
  to a root.  For example, if the calculations for a particular pixel
  converge to the 7th root on the 23rd iteration, NEWTBASIN will color
  that pixel using color #7, but NEWTON will color it using color #23.

  If you have a 256-color mode, use it: the effects can be much livelier
  than those you get with type=newtbasin, and color cycling becomes, like,
  downright cosmic. If your "corners" choice is symmetrical, FRACTINT
  exploits the symmetry for faster display. There is symmetry in
  newtbasin, too, but the current version of the software isn't smart
  enough to exploit it.

  The applicable "params=" values are the same as newtbasin. Try
  "params=4." Other values are 3 through 10. 8 has twice the symmetry and
  is faster. As with newtbasin, an FPU helps.


  COMPLEX NEWTON (type=complexnewton and type=complexbasin)

  Well, hey, "Z^n - 1" is so boring when you can use "Z^a - b" where "a"
  and "b" are complex numbers!  The new "complexnewton" and "complexbasin"
  fractal types are just the old "newton" and "newtbasin" fractal types
  with this little added twist.  When you select these fractal types, you
  are prompted for four values (the real and imaginary portions of "a" and
  "b").  If "a" has a complex portion, the fractal has a discontinuity
  along the negative axis - relax, we finally figured out that it's
  *supposed* to be there!


  LAMBDA SETS (type=lambda)

  This type calculates the Julia set of the formula lambda*Z*(1-Z). That
  is, the value Z[0] is initialized with the value corresponding to each
  pixel position, and the formula iterated. The pixel is colored accord-
  ing to the iteration when the sum of the squares of the real and
  imaginary parts exceeds 4.


                                       20

  Two parameters, the real and imaginary parts of lambda, are required.
  Try 0 and 1 to see the classical fractal "dragon". Then try 0.2 and 1
  for a lot more detail to zoom in on.

  It turns out that all quadratic Julia-type sets can be calculated using
  just the formula z^2+c (the "classic" Julia"), so that this type is
  redundant, but we include it for reason of it's prominence in the
  history of fractals.


  MANDELLAMBDA SETS (type=mandellambda)

  This type is the "Mandelbrot equivalent" of the lambda set. A comment is
  in order here.  Almost all the FRACTINT "Mandelbrot" sets are created
  from orbits generated using formulas like z(n+1) = f(z(n),C), with z(0)
  and C initialized to the complex value corresponding to the current
  pixel. Our reasoning was that "Mandelbrots" are maps of the
  corresponding "Julias". Using this scheme each pixel of a "Mandelbrot"
  is colored the same as the Julia set corresponding to that pixel.
  However, Kevin Allen informs us that the MANDELLAMBDA set appears in the
  literature with z(0) initialzed to a critical point (a point where the
  derivative of the formula is zero), which in this case happens to be the
  point (.5,0). Since Kevin knows more about Dr. Mandelbrot than we do,
  and Dr. Mandelbrot knows more about fractals than we do, we defer!
  Starting with version 14 FRACTINT calculates MANDELAMBDA Dr.
  Mandelbrot's way instead of our way.  But ALL THE OTHER "Mandelbrot"
  sets in FRACTINT are still calculated OUR way! (Fortunately for us, for
  the classic Mandelbrot Set these two methods are the same!)

  Well now, folks, apart from questions of faithfulness to fractals named
  in the literature (which we DO take seriously!), if a formula makes a
  beautiful fractal, it is not wrong. In fact some of the best fractals in
  FRACTINT are the results of mistakes! Neverless, thanks to Kevin for
  keeping us accurate!

  (See description of "initorbit=" command for a way to experiment with
  different orbit intializations).


  PLASMA CLOUDS (type=plasma)

  Plasma clouds ARE real live fractals , even though we didn't know it at
  first.  They are generated by a recursive algorithm that randomly picks
  colors of the corner of a rectangle, and then continues recursively
  quartering previous rectangles. Random colors are averaged with those of
  the outer rectangles so that small neighborhoods do not show much
  change, for a smoothed-out, cloud-like effect. The more colors your
  video mode supports, the better.  The result, believe it or not, is a
  fractal landscape viewed as a contour map, with colors indicating
  constant  elevation.  To see this, save and view with the "3" command
  (see  section on 3D), and your "cloud" will be converted to a mountain!

  You've GOT to try palette cycling on these (hit "+" or "-"). If you
  haven't been hypnotized by the drawing process, the writhing colors will
  do it for sure. We have now implemented subliminal messages to exploit


                                       21

  the user's vulnerable state; their content varies with your bank
  balance, politics, gender, accessibility to a FRACTINT programmer, and
  so on. A free copy of Microsoft C to the first person who spots them.

  This type accepts a single parameter, which determines how abruptly the
  colors change. A value of .5 yields bland clouds, while 50 yields very
  grainy ones. The default value is 2. Zooming is ignored, as each plasma-
  cloud screen is generated randomly.

  The algorithm is based on the Pascal program distributed by Bret Mulvey
  as PLASMA.ARC. We have ported it to C and integrated it with FRACTINT's
  graphics and animation facilities. This implementation does not use
  floating-point math.

  Saved plasma-cloud screens are EXCELLENT starting images for fractal
  "landscapes" created with the "3D" options.


  LAMBDAFN (type=lambdafn with function=[sin|cos|sinh|cosh|exp|log|sqr])

  (Prior to version 14, these types were lambdasine, lambdacos,
  lambdasinh, lambdacos, and lambdaexp. Where we say "lambdasine" or some
  such below, the good reader knows we mean "lambdafn with function=sin".)

  These types calculate the Julia set of the formula lambda*fn(Z), for
  various values of the function "fn", where lambda and Z are both
  complex. Two values, the real and imaginary parts of lambda, should be
  given in the "params=" option.  For the feathery, nested spirals of
  LambdaSines and the frost-on-glass patterns of LambdaCosines, make the
  real part = 1, and try values for the imaginary part ranging from 0.1 to
  0.4 (hint: values near 0.4 have the best patterns). In these ranges the
  Julia set "explodes". For the tongues and blobs of LambdaExponents, try
  a real part of 0.379 and an imaginary part of 0.479.

  A co-processor used to be almost mandatory: each LambdaSine/Cosine
  iteration calculates a hyperbolic sine, hyperbolic cosine, a sine, and a
  cosine (the LambdaExponent iteration "only" requires an exponent, sine,
  and cosine operation)!  However, FRACTINT now computes these
  transcendental functions with fast integer math. In a few cases the fast
  math is less accurate, so we have kept the old slow floating point code.
  To use the old code, invoke with the float=yes option, and, if you DON'T
  have a co-processor, go on a LONG vacation!


  MANDELFN (type=mandelfn with function=[sin|cos|sinh|cosh|exp|log|sqr])

  (Prior to version 14, these types were mandelsine, mandelcos,
  mandelsinh, mandelcos, and mandelexp. Same comment about our lapses
  into the old terminology as above!)

  These are "pseudo-Mandelbrot" mappings for the LambdaFn Julia
  functions. They map to their corresponding Julia sets via the spacebar
  command in exactly the same fashion as the original M/J sets.  In general,
  they are interesting mainly because of that property (the function=exp set
  in particular is rather boring). Generate the appropriate "Mandelfn" set,


                                       22

  zoom on a likely spot where the colors are changing rapidly, and hit the
  space-bar key to plot the Julia set for that particular point.

  Try "FRACTINT TYPE=MANDELFN CORNERS=4.68/4.76/-.03/.03 FUNCTION=COS" for a
  graphic demonstration that we're not taking Mandelbrot's name in vain
  here. We didn't even know these little buggers were here until Mark
  Peterson found this a few hours before the version incorporating
  Mandelfns was released.

  Note: If you created images using the lambda or mandel "fn" types
  prior to version 14, and you wish to update the fractal information in
  the "*.fra" file, simply read the files and save again. You can do this
  in batch mode via a command line like:

       "fractint oldfile.fra savename=newfile.gif batch=yes"

  For example, this procedure can convert a version 13 "type=lambdasine"
  image to a version 14 "type=lambdafn function=sin" GIF89a image.  We do
  not promise to keep this "backward compatibility" past version 14 - if you
  want to keep the fractal information in your *.fra files accurate, we
  recommend conversion.


  BARNSLEY MANDELBROT/JULIA SETS (type=barnsleym1/m2/j1/j2/m3/j3)

  Michael Barnsley has written a fascinating college-level text, "Fractals
  Everywhere," on fractal geometry and its graphic applica-tions. (See the
  bibliography, App. D.) In it, he applies the principle of the M and J
  sets to more general functions of two complex variables.

  We have incorporated three of Barnsley's examples in FRACTINT. Their
  appearance suggests polarized-light microphotographs of minerals, with
  patterns that are less organic and more crystalline than those of the
  M/J sets. Each example has both a "Mandelbrot" and a "Julia" type.
  Toggle between them using the space bar.

  The parameters have the same meaning as they do for the "regular"
  Mandelbrot and Julia. For types M1, M2, and M3, they are used to "warp"
  the image by setting the initial value of Z. For the types J1 through
  J3, they are the values of C in the generating formulas, found in
  Appendix A.

  Be sure to try the <O>rbit function while plotting these types.


  BARNSLEY IFS FRACTALS (type=ifs, ifs3d)

  One of the most remarkable spin-offs of fractal geometry is the ability
  to "encode" realistic images in very small sets of numbers -- parame-
  ters for a set of functions that map a region of two-dimensional space
  onto itself. In principle (and increasingly in practice), a scene of any
  level of complexity and detail can be stored as a handful of numbers,
  achieving amazing "compression" ratios... how about a super-VGA image of
  a forest, more than 300,000 pixels at eight bits apiece, from a 1-KB
  "seed" file?


                                       23

  Again, Michael Barnsley and his co-workers at the Georgia Institute of
  Technology are to be thanked for pushing the development of these
  iterated function systems (IFS).

  Invoking FRACTINT with "TYPE=ifs" defaults to an IFS "fern". Other IFS
  images can be created via the FERN, TRIANGLE and TREE files included
  with FRACTINT, or from user-written files with the default extension
  *.IFS. Use the command-line argument "IFS=filename" or the main-menu <I>
  command to use or manipulate one of these files. Specify whether 2D or
  "3D" if you have not already chosen an IFS type. You will then be asked
  to pick which function to edit. Hitting <Enter> leaves values unchanged.

  Each line in an IFS code file contains the parameters for one of the
  generating functions, e.g. in FERN.IFS:

     a    b     c    d    e    f    p
   ___________________________________
     0    0     0  .16    0    0   .01
   .85   .04 -.04  .85    0  1.6   .85
   .2   -.26  .23  .22    0  1.6   .07
   -.15  .28  .26  .24    0  .44   .07

  The "p" values are the probabilities assigned to each function (how
  often it is used), which add up to one. FRACTINT supports up to 32
  functions, although usually three or four are enough.

  Note that some Barnsley IFS values generate images quite a bit smaller
  than the initial (default) screen. Just bring up the zoom box, center it
  on the small image, and hit the ENTER key to get a full-screen image.

  In order to fully appreciate the 3D fern, since your monitor is presum-
  ably 2D, we have added rotation, translation, and perspective capabili-
  ties. These share values with the same variables used in FRACTINT's
  other 3D facilities; for their meaning see "3D Images", farther on in
  this section. You can enter these values from the command line using:

  rotation=xrot/yrot/zrot       (try 30/30/30)
  shift=xshift/yshift           (shifts BEFORE applying perspective!)
  perspective=viewerposition    (try 200)

  Alternatively, entering "e" (for edit) from main screen or  entering a
  "t" (for "transformations") from the IFS 3D codes-editing screen, will
  allow you to edit these values. The defaults are the same as for regular
  3D, and are not always optimum for the 3D fern. Try rotation=30/30/30.
  Note that applying shift when using perspective changes the picture --
  your "point of view" is moved.

  A truly wild variation of 3D may be seen by entering "2" for the stereo
  mode, putting on red/blue "funny glasses", and watching the fern develop
  with full depth perception right there before your eyes!

  This feature USED to be dedicated to Bruce Goren, as a bribe to get him
  to send us MORE knockout stereo slides of 3D ferns, now that we have
  made it so easy! Bruce, what have you done for us *LATELY* ?? (Just
  kidding, really!)


                                       24



  SIERPINSKI GASKET (type=sierpinski)

  Another pre-Mandelbrot classic, this one found by W. Sierpinski around
  World War I. It is generated by dividing a triangle into four congruent
  smaller triangles, doing the same to each of them, and so on, yea, even
  unto infinity. (Notice how hard we try to avoid reiterating "iterat-
  ing"?)

  If you think of the interior triangles as "holes", they occupy more and
  more of the total area, while the "solid" portion becomes as hopelessly
  fragile as that gasket you HAD to remove without damaging it -- you
  remember, that Sunday afternoon when all the parts stores were closed?
  There's a three-dimensional equivalent using nested tetrahedrons instead
  of triangles, but it generates too much pyramid power to be safely
  unleashed yet.

  There are no parameters for this type. We were able to implement it with
  integer math routines, so it runs fairly quickly even without an FPU.


  QUARTIC MANDELBROT AND JULIA (type=mandel4, julia4)

  These fractal types are the moral equivalent of the original M and J
  sets, except that they use the formula Z(n+1) = Z(n)^4 + C, which adds
  additional pseudo-symmetries to the plots. The "Mandel4" set maps to the
  "Julia4" set via -- surprise! -- the spacebar toggle. The M4 set is kind
  of boring at first (the area between the "inside" and the "out-side" of
  the set is pretty thin, and it tends to take a few zooms to get to any
  interesting sections), but it looks nice once you get there. The Julia
  sets look nice right from the start.

  Other powers, like Z(n)^3 or Z(n)^7, work in exactly the same fashion.
  We used this one only because we're lazy, and Z(n)^4 = (Z(n)^2)^2.


  DISTANCE ESTIMATOR MANDELBROT AND JULIA (formerly type=demm, demj, and
  now type=mandel/type=julia distest=nnn)

  These types have not died, but are only hiding!  They are equivalent to
  the mandel and julia types with the "distest=" option selected with a
  predetermined value.

  The "Distance Estimator Method" (described under "Doodads, Bells and
  Whistles") can be used to produce higher quality images of M and J sets,
  especially suitable for printing in black and white.

  If you have some *.fra files made with the old types demm/demj, you may
  want to convert them to the new form.  See "MANDELFN" section for
  directions to carry out the conversion.






                                       25

  PICKOVER MANDELBROT/JULIA TYPES (type=manfn+zsqrd/julfn+zsqrd,
     manzpowr/julzpowr,manzzpwr/julzzpwr, manfn+exp/julfn+exp -
     formerly included man/julsinzsqrd and man/julsinexp which
     have now been generalized)

  These types have been explored by Clifford A. Pickover, of the IBM
  Thomas J. Watson Research center. As implemented in FRACTINT, they are
  regular Mandelbrot/Julia set pairs that may be plotted with or without
  the "biomorph" option Pickover used to create organic-looking beasties
  (see below). These types are produced with formulas built from the
  functions z^z, z^n, sin(z), and e^z for complex z. Types with "power" or
  "pwr" in their name have an exponent value as a third parameter. For
  example, type=manzpower params=0/0/2 is our old friend the classical
  Mandelbrot, and type=manzpower params=0/0/4 is the Quartic Mandelbrot.
  Other values of the exponent give still other fractals.  Since these
  WERE the original "biomorph" types, we should give an example.  Try:

      FRACTINT type=manfn+sqrd biomorph=0 corners=-8/8/-6/6 function=sin

  to see a big biomorph digesting little biomorphs!


  PICKOVER POPCORN (type=popcorn, type=popcornjul)

  Here is another Pickover idea. This one computes and plots the
  orbits of the dynamic system defined by:

           x(n+1) = x(n) - h*sin(y(n)+tan(3*y(n))
           y(n+1) = y(n) - h*sin(x(n)+tan(3*x(n))

  with the initializers x(0) and y(0) equal to ALL the complex values
  within the "corners" values, and h=.01.  ALL these orbits are
  superimposed, resulting in "popcorn" effect.  You may want to use a
  maxiter value less than normal - Pickover recommends a value of 50.  As
  a bonus, type=popcornjul shows the Julia set generated by these same
  equations with the usual escape-time coloring. Turn on orbit viewing
  with the "O" command, and as you watch the orbit pattern you may get
  some insight as to where the popcorn comes from. Although you can zoom
  and rotate popcorn, the results may not be what you'd expect, due to the
  superimposing of orbits and arbitrary use of color. Just for fun we added
  type popcornjul, which is the plain old Julia set calculated from the
  same formula.


  PETERSON VARIATIONS (type=marksmandel, marksjulia, cmplxmarksmand,
      cmplxmarksjul)

  These fractal types are contributions of Mark Peterson. MarksMandel and
  MarksJulia are two families of fractal types that are linked in the same
  manner as the classic Mandelbrot/Julia sets: each MarksMandel set can be
  considered as a mapping into the MarksJulia sets, and is linked with the
  spacebar toggle. The basic equation for these sets is:

        Z(n+1) = ((lambda^n) * Z(n)^2) + lambda



                                       26

  where Z(0) = 0.0 and lambda is (x + iy) for MarksMandel. For MarksJulia,
  Z(0) = (x + iy) and lambda is a constant (taken from the MarksMandel
  spacebar toggle, if that method is used). The exponent is a positive
  integer or a complex number. We call these "families" because each value
  of the exponent yields a different MarksMandel set, which turns out to
  be a kinda-polygon with (exponent+1) sides. The exponent value is the
  third parameter, after the "initialization warping" values. Typically
  one would use null warping values, and specify the exponent with
  something like "PARAMS=0/0/4", which creates an unwarped, pentagonal
  MarksMandel set.


  UNITY (type=unity)

  This Peterson variation began with curiosity about other "Newton-style"
  approximation processes. A simple one,

     One = (x * x) + (y * y);
     y = (2 - One) * x;
     x = (2 - One) * y;

  produces the fractal called Unity.

  One of its interesting features is the "ghost lines." The iteration loop
  bails out when it reaches the number 1 to within the resolution of a
  screen pixel. When you zoom a section of the image, the bailout
  criterion is adjusted, causing some lines to become thinner and others
  thicker.

  Only one line in Unity that forms a perfect circle: the one at a radius
  of 1 from the origin. This line is actually infinitely thin. Zooming on
  it reveals only a thinner line, up (down?) to the limit of accuracy for
  the algorithm. The same thing happens with other lines in the fractal,
  such as those around |x| = |y| = (1/2)^(1/2) = .7071

  Try some other tortuous approximations using the TEST stub (see below)
  and let us know what you come up with!

  SCOTT TAYLOR/LEE SKINNER VARIATIONS (type=fn(z*z), fn*fn, fn*z+z, fn+fn
       sqr(1/fn), sqr(fn), spider, tetrate, manowar

  Two of FRACTINT's faithful users went bonkers when we introduced the
  "formula" type, and came up with all kinds of variations on escape-
  time fractals using trig functions.  We decided to put them in as regular
  types, but there were just too many! So we defined the types with variable
  functions and let you, the, overwhelmed user, specify what the functions
  should be! Thus Scott Taylor's "z = sin(z) + z^2" formula type is now the
  "fn+fn" regular type, and EITHER function can be one of sin, cos, sinh,
  cosh, exp, log, or sqr. Plus we give you 4 parmeters to set, the complex
  coefficients of the two functions!  Thus the innocent-looking "fn+fn" type
  is really at least 36 different types in disguise, not counting the damage
  done by the parameters!





                                       27

  Lee informs us that you should not judge fractals by their "outer"
  appearance. For example, the images produced by z = sin(z) + z^2 and
  z = sin(z) - z^2 look very similar, but are different when you zoom in.


  KAM TORUS (type=kamtorus, kamtorus3d)

  This type is created by superimposing orbits generated by a set of
  equations, with a variable incremented each time.
           x(0) = y(0) = orbit/3;
           x(n+1) = x(n)*cos(a) + (x(n)*x(n)-y(n))*sin(a)
           y(n+1) = x(n)*sin(a) - (x(n)*x(n)-y(n))*cos(a)
  After each orbit, 'orbit' is incremented by a step size. The parmeters
  are angle "a", step size for incrementing 'orbit', stop value for 'orbit',
  and points per orbit. Try this with a stop value of 5 with sound=x for
  some weird fractal music (ok, ok, fractal noise)! You will also see the
  KAM Torus head into some chaotic territory that Scott Taylor wanted to
  hide from you by setting the defaults the way he did, but now we have
  revealed all!

  The 3D variant is created by treating 'orbit' as the z coordinate.


  BIFURCATION (type=bifurcation, biflambda, bif+sinpi, bif=sinpi)

  The wonder of fractal geometry is that such complex forms can arise from
  such simple generating processes. A parallel surprise has emerged in the
  study of dynamical systems: that simple, deterministic equations can
  yield chaotic behavior, in which the system never settles down to a
  steady state or even a periodic loop. Often such systems behave normal-
  ly up to a certain level of some controlling parameter, then go through
  a transition in which there are two possible solutions, then four, and
  finally a chaotic array of possibilities.

  This emerged many years ago in biological models of population growth.
  Consider a (highly over-simplified) model in which the rate of growth is
  partly a function of the size of the current population:

  New Population =  Growth Rate * Old Population * (1 - Old Population)

  where population is normalized to be between 0 and 1. At growth rates
  less than 200 percent, this model is stable: for any starting value,
  after several generations the population settles down to a stable level.
  But for rates over 200 percent, the equation's curve splits or
  "bifurcates" into two discrete solutions, then four, and soon becomes
  chaotic.

  Type=bifurcation illustrates this model. (Although it's now considered a
  poor one for real populations, it helped get people thinking about
  chaotic systems.) The horizontal axis represents growth rates, from 190
  percent (far left) to 400 percent; the vertical axis normalized popula-
  tion values, from 0 to 4/3. Notice that within the chaotic region, there
  are narrow bands where there is a small, odd number of stable values. It
  turns out that the geometry of this branching is fractal; zoom in where
  changing pixel colors look suspicious, and see for yourself.


                                       28


  The default display has been filtered by allowing the population to
  settle from its initial value for 5000 cycles before plotting maxiter
  population values. To override this filter value, specify a new (smaller)
  one as the first "PARAMS=" value. "PARAMS=1" produces an unfiltered map.

  Many formulae can be used to produce bifurcations.  Mitchel Feigenbaum
  studied lots of bifurcations in the mid-70's, using a HP-65 calculator
  (IBM PCs, Fractals, and Fractint, were all Sci-Fi then !).

  He studied where bifurcations occurred, for the formula r*p*(1-p), the
  one described above.  He found that the ratios of lengths of adjacent
  areas of bifurcation were four and a bit.  These ratios vary, but, as
  the growth rate increases, they tend to a limit of 4.669+.  This helped
  him guess where bifurcation points would be, and saved lots of time.

  When he studied bifurcations of r*sin(PI*p) he found a similar pattern,
  which is not surprising in itself.  However, 4.669+ popped out, again.
  Different formulae, same number ?  Now, THAT's surprising !  He tried
  many other formulae and ALWAYS got 4.669+ - Hot Damn !!!  So hot, in
  fact, that he phoned home and told his Mom it would make him Famous !
  He also went on to tell other scientists.  The rest is History...

  (It has been conjectured that if Feigenbaum had had a copy of Fractint,
  and used it to study bifurcations, he may never have found his Number,
  as it only became obvious from long perusal of hand-written lists of
  values, without the distraction of wild colour-cycling effects !).

  We now know that this number is as universal as PI or E. It appears in
  situations ranging from fluid-flow turbulence, electronic oscillators,
  chemical reactions, and even the Mandelbrot Set - yup, fraid so :
  "budding" of the Mandelbrot Set along the negative real axis occurs at
  intervals determined by Feigenbaum's Number, 4.669201660910.....

  Fractint does not make direct use of the Feigenbaum Number (YET !).
  However, it does now reflect the fact that there is a whole sub-species
  of Bifurcation-type fractals.  Those implemented to date, and the
  related formulae, (writing P for pop[n+1] and p for pop[n]) are :

    bifurcation   P =  p + r*p*(1-p)      Verhulst Bifurcations.
    biflambda     P =      r*p*(1-p)      Real equivalent of Lambda Sets.
    bif+sinpi     P =  p + r*sin(PI*p)    Population scenario based on...
    bif=sinpi     P =      r*sin(PI*p)    ...Feigenbaum's second formula.

  It took a while for bifurcations to appear here, despite them being
  over a century old, and intimately related to chaotic systems.
  However, they are now truly alive and well in Fractint!


  LORENZ ATTRACTORS (type=lorenz and type=lorenz3d)

  The "Lorenz Attractor" is a "simple" set of three deterministic
  equations developed by Edward Lorenz while studying the non-
  repeatability of weather patterns.  The weather forecaster's basic
  problem is that even very tiny changes in initial patterns ("the beating


                                       29

  of a butterfly's wings" - the official term is "sensitive dependence on
  initial conditions") eventually reduces the best weather forecast to
  rubble.

  The lorenz attractor is the plot of the orbit of a dynamic system
  consisting of three first order non-linear differential equations. The
  solution to the differential equation is vector-valued function of one
  variable.  If you think of the variable as time, the solution traces an
  orbit.  The orbit is made up of two spirals at an angle to each other in
  three dimensions. We change the orbit color as time goes on to add a
  little dazzle to the image.  The equations are:

                  dx/dt = -a*x + a*y
                  dy/dt =  b*x - y   -z*x
                  dz/dt = -c*z + x*y

  We solve these differential equations approximately using a method known
  as the first order taylor series.  Calculus teachers everywhere will
  kill us for saying this, but you treat the notation for the derivative
  dx/dt as though it really is a fraction, with "dx" the small change in x
  that happens when the time changes "dt".  So multiply through the above
  equations by dt, and you will have the change in the orbit for a small
  time step. We add these changes to the old vector to get the new vector
  after one step. This gives us:

               xnew = x + (-a*x*dt) + (a*y*dt)
               ynew = y + (b*x*dt) - (y*dt) - (z*x*dt)
               znew = z + (-c*z*dt) + (x*y*dt)

               (default values: dt = .02, a = 5, b = 15, c = 1)

  We connect the successive points with a line, project the resulting 3D
  orbit onto the screen, and voila! The Lorenz Attractor!

  We have added two versions of the Lorenz Attractor.  "Type=lorenz" is
  the Lorenz attractor as seen in everyday 2D.  "Type=lorenz3d" is the
  same set of equations with the added twist that the results are run
  through our perspective 3D routines, so that you get to view it from
  different angles (you can modify your perspective "on the fly" using the
  transformation option of the <E>ditor command.) If you set the "stereo"
  option to "2", and have red/blue funny glasses on, you will see the
  attractor orbit with depth perception.

  Hint: the default perspective values (x = 60, y = 30, z = 0) aren't the
  best ones to use for fun Lorenz Attractor viewing.  Experiment a bit -
  start with rotation values of 0/0/0 and then change to 20/0/0 and 40/0/0
  to see the attractor from different angles.- and while you're at it, use
  a non-zero perspective point Try 100 and see what happens when you get
  *inside* the Lorenz orbits.  Here comes one - Duck!  While you are at
  it, turn on the sound with the "X". This way you'll at least hear it
  coming!

  Different Lorenz attractors can be created using different parameters.
  Four parameters are used. The first is the time-step (dt). The default
  value is .02. A smaller value makes the plotting go slower; a larger


                                       30

  value is faster but rougher. A line is drawn to connect successive orbit
  values. The 2nd, third, and fourth parameters are coefficients used in
  the differential equation (a, b, and c). The default values are 5, 15,
  and 1. Try changing these a little at a time to see the result.


  ROSSLER ATTRACTORS (type=rossler3D)

  This fractal is named after the German Otto Rossler, a non-practicing
  medical doctor who approached chaos with a bemusedly philosophical
  attitude.  He would see strange attractors as philosophical objects.
  His fractal namesake looks like a band of ribbon with a fold in it. All
  we can say is we used the same calculus-teacher-defeating trick of
  multiplying the equations by "dt" to solve the differential equation and
  generate the orbit.  This time we will skip straight to the orbit
  generator -if you followed what we did above with Lorenz you can easily
  reverse engineer the differential equations.
               xnew = x - y*dt -   z*dt
               ynew = y + x*dt + a*y*dt
               znew = z + b*dt + x*z*dt - c*z*dt
  Default parameters are dt = .04, a = .2, b = .2, c = 5.7

  HENON ATTRACTORS (type=henon)

  Michel Henon was an astronomer at Nice observatory in southern France.
  He came to the subject of fractals via investigations of the orbits of
  astronomical objects.  The strange attractor most often linked with
  Henon's name comes not from a differential equation, but from the world
  of discrete mathematics - difference equations. The Henon map is an
  example of a very simple dynamic system that exhibits strange behavior.
  The orbit traces out a characteristic banana shape, but on close
  inspection, the shape is made up of thicker and thinner parts.  Upon
  magnification, the thicker bands resolve to still other thick and thin
  components.  And so it goes forever! The equations that generate this
  strange pattern perform the mathematical equivalent of repeated
  stretching and folding, over and over again.

               xnew =  1 + y - a*x*x
               ynew =  b*x

  The default parameters are a=1.4 and b=.3.


  PICKOVER ATTRACTORS (type=pickover)

  Clifford A. Pickover of the IBM Thomas J. Watson Research center is such a
  creative source for fractals that we attach his name to this one only with
  great trepidation.  Probably tomorrow he'll come up with another one and
  we'll be back to square one trying to figure out a name!

  This one is the three dimensional orbit defined by:
               xnew = sin(a*y) - z*cos(b*x)
               ynew = z*sin(c*x) - cos(d*y)
               znew = sin(x)
  Default parameters are: a = 2.24, b = .43, c = -.65, d = -2.43


                                       31

  GINGERBREADMAN FRACTAL (type=gingerbreadman)

  This simple fractal is a charming example stolen from "Science of
  Fractal Images", p. 149.  Look closely, and you will see that the
  gingerbreadman contains infinitely many copies of himself at all
  different scales.

               xnew = 1 - y + |x|
               ynew = x

  There are no parameters.


  TEST (type=test)

  This is a stub that we (and you!) use for trying out new fractal types.
  "Type=test" fractals make use of FRACTINT's structure and features for
  whatever code is in the routine 'testpt()' (located in the small source
  file TESTPT.C) to determine the color of a particular pixel.

  If you have a favorite fractal type that you believe would fit nicely
  into FRACTINT, just rewrite the C function in TESTPT.C (or use the
  prototype function there, which is a simple M-set implementation) with
  an algorithm that computes a color based on a point in the complex
  plane.

  After you get it working, send your code to one of the authors and we
  might just add it to the next release of FRACTINT, with full credit to
  you. Our criteria are: 1) an interesting image and 2) a formula
  significantly different from types already supported. (Bribery may also
  work. THIS author is completely honest, but I don't trust those other
  guys.) Be sure to include an explanation of your algorithm and the
  parameters supported, preferably formatted as you see here to simplify
  folding it into the documentation.


  FORMULA (type=formula)

  Fractint now has a new 'type=formula' fractal type.  This is a "roll-
  your-own" fractal interpreter - you don't even need a compiler!

  To run a "type=formula" fractal, you first need to build a text file
  containing formulas (there's a sample file - FRACTINT.FRM - included
  with this distribution).  When you select the "formula" fractal type,
  you are prompted first for the name of your file.  Then, after the
  program locates the file and scans it for formulas, you are prompted for
  the formula name you wish to run.  After prompting for any parameters,
  the formula is parsed for syntax errors and then the fractal is
  generated.








                                       32

  There are also two new command-line options that work with type=formula
  ("formulafile=" and "formulaname=") if you are using this new fractal
  type in batch mode.

  (the following documentation is supplied by Mark Peterson, who wrote the
  formula interpreter):

  Formula fractals allow you to create your own fractal formulas.  The
  general format is:

     Mandelbrot(XAXIS) { z = Pixel:  z = sqr(z) + pixel, |z| <= 4 }
        |         |          |                |              |
       Name     Symmetry    Initial         Iteration       Bailout
                            Condition                       Criteria

  Initial conditions are set, then the iterations performed until the
  bailout criteria is true or 'z' turns into a periodic loop.

  All variables are created automatically by their usage and treated as
  complex.  If you declare 'v = 2' then the variable 'v' is treated as a
  complex with an imaginary value of zero.

            Predefined Variables (x, y)
            --------------------------------------------
            z              used for periodicity checking
            p1             parameters 1 and 2
            p2             parameters 3 and 4
            pixel          screen coordinates

            Precedence
            --------------------------------------------
            1              sin(), cos(), sinh(), cosh(), sqr(),
                           log(), exp(), abs(), conj(), real(),
                           imag()
            2              - (negation), ^ (power)
            3              * (multiplication), / (division)
            4              + (addition), - (subtraction)
            5              = (assignment)
            6              < (less than), <= (less than or equal to)

  Precedence may be overridden by use of parenthesis.  Note the modulus
  squared operator |z| is also parenthetic and always sets the imaginary
  component to zero.  This means 'c * |z - 4|' first subtracts 4 from z,
  calculates the modulus squared then multiplies times 'c'.  Nested
  modulus squared operators require overriding parenthesis:

            c * |z + (|pixel|)|

  The formulas are performed using either integer or floating point
  mathematics depending on the type of math you have setup.  If you do
  not have an FPU then type MPC math is performed in lieu of traditional
  floating point.

  Remember that when using integer math there is a limited dynamic
  range, so what you think may be a fractal could really be just a


                                       33

  limitation of the integer math range.  God may work with integers, but
  His dynamic range is many orders of magnitude greater than our puny 32
  bit mathematics!  Always verify with the floating point.


  JULIBROTS (type=julibrot)

  (the following documentation is supplied by Mark Peterson, who "invented"
  the Julibrot algorithm)

  There is a very close relationship between the Mandelbrot set and
  Julia sets of the same equation.  To draw a Julia set you take the
  basic equation and vary the initial value according to the two
  dimensions of screen leaving the constant untouched.  This method
  diagrams two dimensions of the equation, 'x' and 'iy', which I refer
  to as the Julia x and y.

       z(0) = screen coordinate (x + iy)
       z(1) = (z(0) * z(0)) + c, where c = (a + ib)
       z(2) = (z(1) * z(0)) + c
       z(3) = . . . .

  The Mandelbrot set is a composite of all the Julia sets.  If you take
  the center pixel of each Julia set and plot it on the screen
  coordinate corresponding to the value of c, a + ib, then you have the
  Mandelbrot set.

       z(0) = 0
       z(1) = (z(0) * z(0)) + c, where c = screen coordinate (a + ib)
       z(2) = (z(1) * z(1)) + c
       z(3) = . . . .

  I refer to the 'a' and 'ib' components of 'c' as the Mandelbrot 'x'
  and 'y'.

  All the 2 dimensional Julia sets correspond to a single point on the 2
  dimensional Mandelbrot set, making a total of 4 dimensions associated with
  our equation.  Visualizing 4 dimensional objects is not as difficult as it
  may sound at first if you consider we live in a 4 dimensional world.  The
  room around you is three dimensions and as you read this text you are
  moving through the fourth dimension of time. You and everything around your
  are 4 dimensional objects - which is to say 3 dimensional objects moving
  through time.  We can think of the 4 dimensions of our equation in the same
  manner, this is as a 3 dimensional object evolving over time - sort of a 3
  dimensional fractal movie.  The fun part of it is you get to pick the
  dimension representing time!

  To construct the 4 dimensional object into something you can view on the
  computer screen you start with the simple 2 dimensions of the Julia set.
  I'll treat the two Julia dimensions as the spatial dimensions of height and
  width, and the Mandelbrot 'y' dimension as the third spatial dimension of
  depth.  This leaves the Mandelbrot 'x' dimension as time.  Draw the Julia
  set associated with the Mandelbrot coordinate (-.83, -.25), but instead of
  setting the color according to the iteration level it bailed out on, make
  it a two color drawing where the pixels are black for iteration levels less


                                       34

  than 30, and another color for iteration levels greater than or equal to
  30.  Now increment the Mandelbrot 'y' coordinate by a little bit, say
  (-.83, -.2485), and draw another Julia set in the same manner using a
  different color for bailout values of 30 or greater.  Continue doing this
  until you reach (-.83, .25).  You now have a three dimensional
  representation of the equation at time -.83.  If you make the same drawings
  for points in time before and after -.83 you can construct a 3 dimensional
  movie of the equation which essentially is a full 4 dimensional
  representation.

  In the Julibrot fractal available with this release of FRACTINT the spatial
  dimensions of height and width are always the Julia dimensions. The
  dimension of depth is determined by the Mandelbrot coordinates.  The
  program will consider the dimension of depth as the line between the two
  Mandelbrot points.  To draw the image in our previous example you would
  set the 'From Mandelbrot' to (-.83, .25) and the 'To Mandelbrot' as (-.83,
  -.25).  If you set the number of 'z' pixels to 128 then the program will
  draw the 128 Julia sets found between Mandelbrot points (-.83, .25) and
  (-.83, -.25).  To speed things up the program doesn't actually calculate
  ALL the coordinates of the Julia sets.  It starts with the a pixel a the
  Julia set closest to the observer and moves into the screen until it either
  reaches the required bailout or the limit to the range of depth.  Zooming
  can be done in the same manner as with other fractals.  The visual effect
  (with other values unchanged) is similar to putting the boxed section under
  a pair of magnifying glasses.

  The variable associated with penetration level is the level of bailout
  there you decide to make the fractal solid.  In other words all bailout
  levels less than the penetration level are considered to be transparent,
  and those equal or greater to be opaque.  The farther away the apparent
  pixel is the dimmer the color.

  The remainder of the parameters are needed to construct the red/blue
  picture so that the fractal appears with the desired depth and proper 'z'
  location.  With the origin set to 8 inches beyond the screen plane and the
  depth of the fractal at 8 inches the default fractal will appear to start
  at 4 inches beyond the screen and extend to 12 inches if your eyeballs are
  2.5 inches apart and located at a distance of 24 inches from the screen.
  The screen dimensions provide the reference frame.

  To the human eye blue appears brighter than red.  The Blue:Red ratio is
  used to compensate for this fact.  If the image appears reddish through the
  glasses raise this value until the image appears to be in shades of gray.
  If it appears bluish lower the ratio.

  Julibrots can only be shown in 256 red/blue colors for viewing in either
  stereo-graphic (red/blue funny glasses) or gray-scaled.  FRACTINT
  automatically loads either GLASSES1.MAP or ALTERN.MAP as appropriate.

  DIFFUSION LIMITED AGGREGATION (type=diffusion)

  This type begins with a single point in the center of the screen.
  Subsequent points move around randomly until coming into contact with the
  first point, at which time their locations are fixed and they are colored
  randomly.  This process repeats until the fractals reaches the edge of the


                                       35

  screen.  Use the show orbits function to see the points' random motion.

  One unfortunate problem is that on a large screen, this process will
  tend to take eons.  To speed things up, the points are restricted to a box
  around the initial point.  The first and only parameter to diffusion
  contains the size of the border between the fractal and the edge of the
  box.  If you make this number small, the fractal will look more solid and
  will be generated more quickly.

  Diffusion was inspired by a Scientific American article a couple of years
  back which includes actual pictures of real physical phenomena that behave
  like this.

  Thanks to Adrian Mariano for providing the diffusion code and documentation.


  MAGNETIC FRACTALS (type=magnet1m,magnet1j,magnet2m,magnetic2j)

  These fractals use formulae derived from the study of hierarchical
  lattices, in the context of magnetic renormalisation transformations.
  This kinda stuff is useful in an area of theoretical physics that deals
  with magnetic phase-transitions (predicting at which temperatures a
  given substance will be magnetic, or non-magnetic).  In an attempt to
  clarify the results obtained for Real temperatures (the kind that you
  and I can feel), the study moved into the realm of Complex Numbers,
  aiming to spot Real phase-transitions by finding the intersections of
  lines representing Complex phase-transitions with the Real Axis.  The
  first people to try this were two physicists called Yang and Lee, who
  found the situation a bit more complex than first expected, as the
  phase boundaries for Complex temperatures are (surprise !) fractals.

  And that's all the technical (?) background you're getting here !  For
  more details (are you SERIOUS ?!) read "The Beauty of Fractals".  When
  you understand it all, you might like to re-write this section, before
  you start your new job as a professor of theoretical physics...

  In Fractint terms, the important bits of the above are "Fractals",
  "Complex Numbers", "Formulae", and "The Beauty of Fractals".  Lifting
  the Formulae straight out of the Book and iterating them over the
  Complex plane (just like the Mandelbrot set) produces Fractals.

  The formulae are a bit more complicated than the Z^2+C used for the
  Mandelbrot Set, that's all.  They are :

                 /  Z^2 + (C-1)  \
      MAGNET1 : |  -------------  | ^ 2
                 \  2*Z + (C-2)  /
                 /      Z^3 + 3*(C-1)*Z + (C-1)*(C-2)      \
      MAGNET2 : |  ---------------------------------------  | ^ 2
                 \  3*(Z^2) + 3*(C-2)*Z + (C-1)*(C-2) - 1  /

  These aren't quite as horrific as they look (oh yeah ?!) as they only
  involve two variables (Z and C), but cubing things, doing division, and
  eventually squaring the result (all in Complex Numbers) don't exactly
  spell S-p-e-e-d !  These are NOT the fastest fractals in Fractint !


                                       36


  As you might expect, for both formulae there is a single related
  Mandelbrot-type set (magnet1m, magnet2m) and an infinite number of
  related Julia-type sets (magnet1j, magnet2j), with the usual toggle
  between the corresponding Ms and Js via the space-bar.

  If you fancy delving into the Julia-types by hand, you will be prompted
  for the Real and Imaginary parts of the parameter denoted by C.  The
  result is symmetrical about the Real axis (and therefore the initial
  image gets drawn in half the usual time) if you specify a value of Zero
  for the Imaginary part of C.

  Fractint Historical Note:  Another complication (besides the formulae)
  in implementing these fractal types was that they all have a finite
  attractor (1.0 + 0.0i), as well as the usual one (Infinity).  This fact
  spurred the development of Finite Attractor logic in Fractint.  Without
  this code you can still generate these fractals, but you usually end up
  with a pretty boring image that is mostly deep blue "lake", courtesy of
  Fractint's standard Periodicity Checking.  See the Finite Attractors
  section for more information on this aspect of Fractint internals.

  (Thanks to Kevin Allen for Magnetic type documentation above).

  "3D" IMAGES

  FRACTINT can now restore images in "3D". Important: we use quotation
  marks because it does not CREATE images of 3D fractal objects (there
  are such, but we're not there yet.) Instead, it restores .GIF images
  (or .FRA images -- see Sec. 4) as a 3D PROJECTION or STEREO IMAGE
  PAIR. The iteration values you've come to know and love, the ones that
  determine pixel colors, are translated into "height" so that your
  saved screen becomes a landscape viewed in perspective. You can even
  wrap the landscape onto a sphere for realistic-looking planets and
  moons that never existed outside your PC!

  We suggest starting with a saved plasma-cloud screen. Hit <3> in main
  command mode to begin the process, enter the filename. If no extension
  is specified, a .GIF extension is assumed. If no .GIF is found, it
  will assume a .GIF extension. If no match is then found, if will
  attempt to match the file with no extension. Then it will prompt you
  for the video mode if appropriate.

  Now, you'll be bombarded with a long series of options. Not to worry:
  all of them have defaults chosen to yield an acceptable starting
  image, so the first time out just pump your way through with the
  <Enter> key. When you enter a different value for any option, that
  becomes the default value the next time you hit <3>, so you can change
  one option at a time until you get what you want. Generally <ESC> will
  take you back to the previous screen.








                                       37

  3D MODE SELECTION

  After the filename prompt and video mode check, you're presented with
  a "3d Mode Selection" screen. Each selection will have defaults
  entered if you wish to change any of the defaults use the cursor keys
  to move through the menu. When you're satisfied press <Enter>.

  Here are the options and what they do:

  Preview Mode:

       Preview mode provides a rapid look at your transformed image
       using by skipping a lot of rows and filling the image in. Good
       for quickly discovering the best parameters. Let's face it, the
       FRACTINT authors most famous for "blazingly fast" code *DIDN'T*
       write the 3D routines!

  Show Box:

       If you have selected Preview Mode you have another option to
       worry about. This is the option to show the image box in scaled
       and rotated coordinates x, y, and z. The box only appears in
       rectangular transformations and shows how the final image will be
       oriented. If you select light source in the next screen, it will
       also show you the light source vector so you can tell where the
       light is coming from in relation to your image. Sorry no head or
       tail on the vector yet.

  Coarseness:

       This sets how many divisions the image will be divided into
       in the y direction, if you select preview mode above, or
       grid fill in the "Select Fill Type" screen next.

  Spherical Projection:

       The next question asks if you want a sphere projection. This will
       take  your image and map it onto a plane if you answer "no" or a
       sphere if you answer "yes" as described above. Try  it and you'll
       see what we mean.

  Stereo:

       Stereo sound in FRACTINT? Well, not yet. FRACTINT now allows
       you to create 3D images for use with red/blue glasses like
       3D comics you may have seen, or images like Captain EO.

       Option 0 is normal old 3D you can look at with just your
       eyes.

       Options 1 and 2 require the special red/blue-green glasses.
       They are meant to be viewed right on the screen or on a
       color print off of the screen. The image can be made to
       hover entirely or partially in front of the screen. Great
       fun! These two options give a gray scale image when viewed.


                                       38


       Option 1 gives 64 shades of gray but with half the spatial
       resolution you have selected. It works by writing the red and
       blue images on adjacent pixels, which is why it eats half your
       resolution. In general, we recommend you use this only with
       resolutions above 640x350. Use this mode for continuous potential
       landscapes where you *NEED* all those shades.

       Option "2" gives you full spatial resolution but with only 16
       shades of gray. If the red and blue images overlap, the colors
       are mixed. Good for wire-frame images (we call them surface grids),
       lorenz3d and ifs3d. Works fine in 16 color modes.

       Option 3 is for creating stereo pair images for view later
       with more specialized equipment. It allows full color images
       to be presented in glorious stereo. The left image presented
       on the screen first. You may photograph it or save it. Then
       the second image is presented, you may do the same as the
       first image. You can then take the two images and convert
       them to a stereo image pair as outlined by Bruce Goren (see
       below). When you are satisfied with your selections press
       enter to go to the next screen which will appear below this
       one.

  SELECT FILL TYPE Screen

  These options exist because in the course of the 3D projection,
  portions of the original image may be stretched to fit the new
  surface. Points of an image that formerly were right next to each
  other, now may have a space between them. These options generally
  determine what to do with the space between the mapped dots.

  For an illustration, pick the second option "just draw the points",
  which just maps points to corresponding points. Generally this will
  leave empty space between many of the points. Therefore you can choose
  various algorithms that "fill in" the space between the points in
  various ways.

  Now, try the first option "make a surface grid." This option will make
  a grid of the surface which is as many divisions in the original "y"
  direction as was set in "coarse" in the first screen. It is very fast,
  and can give you a good idea what the final relationship of parts of
  your picture will look like.

  Try the second option, "connect the dots (wire frame)", then "surface
  fills - (colors interpolated)" and "(colors not interpolated), the
  general favorite of the authors. Solid fill, while it reveals the
  pseudo-geology under your pseudo-landscape, inevitably takes longer.

  Now try the light source fill types. These two algorithms allow
  you to position the "sun" over your "landscape." Each pixel is
  colored according to the angle the surface makes with an
  imaginary light source. You will be asked to enter the three
  coordinates of the vector pointing toward the light in one of the
  following screens.


                                       39


  Light source before transformation calculates the illumination
  before doing the coordinate transformations, and is slightly
  faster. If you generate a sequence of images where one rotation
  is progressively changed, the effect is as if the image and the
  light source are fixed in relation to each other and you orbit
  around the image.

  Light source after transformation applies the transformations
  first, then calculates the illumination. If you generate a
  sequence of images with progressive rotation as above the effect
  is as if you and the light source are fixed and the object is
  rotating.

  For ease of discussion we will refer to the following fill types
  by these numbers:
         1 - surface grid
         2 - (default) - no fill at all - just draw the dots.
         3 - wire frame - joins points with lines
         4 - surface fill - (colors interpolated)
         5 - surface fill - (interpolation turned off)
         6 - solid fill - draws lines from the "ground" up to the point
         7 - surface fill with light model - calculated before 3D transforms
         8 - surface fill with light model - calculated after 3D transforms

  Types 4, 7, and 8 interpolate colors when filling, making a very
  smooth fill if the palette is continuous. This may not be desirable if
  the palette is not continuous. Type 5 is the same as type 4 with
  interpolation turned off. You might want to use fill type 5, for
  example, to project a .GIF photograph onto a sphere. With type 4, you
  might see the filled-in points, since chances are the palette is not
  continuous; type 5 fills those same points in with the colors of
  adjacent pixels. However, for most fractal images, fill type 4 works
  better.


  STEREO 3D VIEWING

  If you selected Stereo option 1, 2 or 3 you will be presented another
  screen to select from. We suggest you definitely use defaults at first
  on this one.

  Funny Glasses Parameters

  When you look at an image with both eyes, each eye sees the image in
  slightly different perspective because they see it from different
  places.

  The first selection you must make is ocular separation, the distance
  the between the viewers eyes. This is measured as a % of screen and is
  an important factor in setting the position of the final stereo image
  in front of or behind the CRT Screen.

  The second selection is convergence, also as a % of screen. This
  tends to move the image forward and back to set where it floats.


                                       40

  More positive values move the image towards the viewer. The value
  of this parameter needs to be set in conjunction with the setting of
  ocular separation and the perspective distance. It directly adjusts
  the overall separation of the two stereo images. Beginning anaglyphers
  love to create images floating mystically in front of the screen, but
  grizzled old 3D veterans look upon such antics with disdain, and
  believe the image should be safely inside the monitor where it
  belongs!

  Left and Right Red and Blue image crop (% of screen also) help
  keep the visible part of the right image the same as the visible
  part of the left by cropping them. If there is too much in the
  field of either eye that the other doesn't see, the stereo effect
  can be ruined.

  Red and Blue brightness factor. The generally available red/blue-
  green glasses, made for viewing on ink on paper and not the light
  from a CRT, let in more red light in the blue-green lens than we
  would like. This leaves a ghost of the red image on the blue-
  green image (definitely not desired in stereo images). We have
  countered this by adjusting the intensity of the red and blue
  values on the CRT. In general you should not have to adjust this.

  The final entry is Map file name. If you have a special map file
  you want to use for Stereo 3D this is the place to enter its
  name. Generally glasses1.map is for type 1 (alternating pixels), and
  glasses2.map is for type 2 (superimposed pixels). Grid.map is great
  for wire-frame images using 16 color modes.



  RECTANGULAR COORDINATE TRANSFORMATION

  The first entries are rotation values around the X, Y, and Z axes. Think
  of your starting image as a flat map: the X value tilts the bottom of
  your monitor towards you by X degrees, the Y value pulls the left side
  of the monitor towards you, and the Z value spins it counter-clockwise.
  Note that these are NOT independent rotations: the image is rotated
  first along the X-axis, then along the Y-axis, and finally along the Z-
  axis. Those are YOUR axes, not those of your (by now hopelessly skewed)
  monitor. All rotations actually occur through the center of the original
  image.

  Then there are three scaling factors in per cent. Initially, leave the X
  and Y axes alone and play with Z, now the vertical axis, which
  translates into surface "roughness."  High values of Z make spiky, on-
  beyond-Alpine mountains and improbably deep valleys; low values make
  gentle, rolling terrain. Negative roughness is legal: if you're doing an
  M-set image and want Mandelbrot Lake to be below the ground, instead of
  eerily floating above, try a roughness of about -30%.

  Next we need a water level -- really a minimum-color value that performs
  the function "if (color < waterlevel) color = waterlevel". So it plots
  all colors "below" the one you choose at the level of that color, with
  the effect of filling in "valleys" and converting them to "lakes."


                                       41


  Now we enter a perspective distance, which you can think of as the
  "distance" from your eye to the image. A zero value (the default) means
  no perspective calculations, which allows use of a faster algorithm.

  For non-zero values, picture a box with the original X-Y plane of your
  flat fractal on the bottom, and your 3D fractal inside. A perspective
  value of 100% places your eye right at the edge of the box and yields
  fairly severe distortion, like a close view through a wide-angle lens.
  200% puts your eye as far from the front of the box as the back is
  behind. 300% puts your eye twice as far from the front of the box as the
  back is, etc. Try about 150% for reasonable results. Much larger values
  put you far away for even less distortion, while values smaller than
  100% put you "inside" the box. Try larger values first, and work your
  way in.

  Next, you are prompted for two types of X and Y shifts (now back in the
  plane of your screen) that let you move the final image around if you'd
  like to re-center it. The first set, x and y shift with perspective, move
  the image and the effect changes the perspective you see. The second set,
  "x and y adjust without perspective", move the image but do not change
  perspective.  They are used just for positioning the final image on the
  screen.

  Now,  you are asked for a range of "transparent" colors, if any. This
  option is most useful when using the <O>verlay command below. Enter the
  color range (minimum and maximum value) for which you do not want to
  overwrite whatever may already be on the screen. The default is no
  transparency (overwrite everything).

  Now, for the final option. This one will smooth the transition between
  colors by randomizing them and reduce the banding that occurs with some
  maps. Select the value of randomize to between 0 (for no effect) and 7
  (to randomize your colors almost beyond use). 3 is a good starting point.

  Well, OK, we lied. If you selected one of the light source fill options,
  there are still MORE options.

  If you have selected a fill type which uses light source, you can select
  the final image to be either in monochrome or full color. 0 selects
  monochrome and 1 selects glorious full color.

  Thats all for this screen. Press enter and the next and final screen will
  appear (honestly!).


  Light Source Parameters

  This one deals with all the aspects of light source.

  You must chose the direction of the light from the light source. This
  will be scaled in the x, y, and z directions the same as the image. For
  example, 1,1,3 positions the light to come from the lower right front
  of the screen in relation to the untransformed image. It is important
  to remember that these coordinates are scaled the same as your image.


                                       42

  Thus, "1,1,1" positions the light to come from a direction of equal
  distances to the right, below and in front of each pixel on the original
  image. However, if the x,y,z scale is set to 90,90,30 the result will be
  from equal distances to the right and below each pixel but from only 1/3
  the distance in front of the screen ie. it will be low in the sky, say,
  afternoon or morning.

  Then you are asked for a smoothing factor. Unless you used continuous
  potential (see Sec. 4) when generating the starting image, the
  illumination when using light source fills may appear "sparkly", like
  a sandy beach in bright sun. A smoothing factor of 2 or 3 will allow you
  to see the large-scale shapes better.

  This is primarily useful when doing light source fill types with plasma
  clouds. But if your fractal is not a plasma cloud and has features with
  sharply defined boundaries (e.g. Mandelbrot Lake), the smoothing may
  cause the colors to run. This is a feature, not a bug. (A copyrighted
  response of [your favorite commercial software company here], used by
  permission.)

  The ambient option sets the minimum light value a surface has if it has
  no direct lighting at all. All light values are scaled from this value to
  white. This effectively adjusts the depth of the shadows and sets the
  overall contrast of the image.

  If you selected the full color option, you have a few more choices.
  The next is the haze factor. Set this to make distant objects more hazy.
  Close up objects will have little effect, distant objects will have most.
  0 disables the function. 100 is the maximum effect, the farthest objects
  will be lost in the mist. Currently, this does not really use distance
  from the viewer, we cheat and use the y value of the original image. So
  the effect really only works if the y-rotation (set earlier) is between
  +/- 30.

  Finally, absolutely the last option (this time we mean it): you can chose
  the name under which to save your light file. If you have a RAM disk
  handy, you might want to create the file on it for speed, so include its
  full path name in this option. If you have set warn=yes then the file
  name will be incremented to avoid over-writing previous files. By the way,
  the background on the full color file is sky blue instead of black.

  You'll probably want to adjust the final colors for monochrome fill types
  using light source via color cycling. Try one of the more continuous
  palettes (<F8> through <F10>), or load the GRAY palette with the
  <A>lternate-map command.

  Note that any image loaded up in 3D is treated as if it were a plasma
  cloud: we have NO idea how to retain the ability to zoom and pan around
  a 3D image that has been twisted, stretched, perspective-ized, and
  water-leveled. Actually, we do, but it involves the kind of hardware that
  Industrial Light & Magic, Pixar et al. use for feature films. So if you'd
  like to send us a check equivalent to George Lucas' net from the "Star
  Wars" series...




                                       43

  Now, lie down for a while in a quiet room with a damp washcloth on your
  forehead. Feeling better? Good -- because it's time to go back almost to
  the top of the 3D options and just say yes to:

  SPHERICAL PROJECTION

  Picture a globe lying on its side, "north" pole to the right. (It's our
  planet, and we'll position it the way we like.) You will be mapping the
  X and Y axes of the starting image to latitude and longitude on the
  globe, so that what was a horizontal row of pixels follows a line of
  longitude. The defaults exactly cover the hemisphere facing you, from
  longitude 180 degrees (top) to 0 degrees (bottom) and latitude -90
  (left) to latitude 90 (right). By changing them you can map the image to
  a piece of the hemisphere or wrap it clear around the globe.

  The next entry is for a radius factor that controls the over-all size of
  the globe. All the rest of the entries are the same as in the landscape
  projection. You may want less surface roughness for a plausi-ble look,
  unless you prefer small worlds with big topography, a la "The Little
  Prince."

  WARNING: When the "construction" process begins at the edge of the globe
  (default) or behind it, it's plotting points that will be hidden by
  subsequent points as the process sweeps around the sphere toward you.
  Our nifty hidden-point algorithms "know" this, and the first few dozen
  lines may be invisible unless a high mountain happens to poke over the
  horizon. If you start a spherical projection and the screen stays black,
  wait for a while (a longer while for higher resolution or fill type 6)
  to see if points start to appear. Would we lie to you? If you're still
  waiting hours later, first check that the power's still on, then
  consider a faster system.


  Once you're familiar with the effects of the 3D option values you have a
  variety of options on how to specify them. You can specify them all on
  the command line (there ARE a lot of them so they may not all fit within
  the DOS command line limits), with an SSTOOLS.INI file, or with a
  command file.

  Here's an example for you power FRACTINTers, the command

            FRACTINT MYFILE SAVENAME=MY3D 3D= BATCH=YES

  would make FRACTINT load MYFILE.GIF, re-plot it as a 3D landscape
  (taking all of the defaults), save the result as MY3D.GIF, and exit to
  DOS. By the time you've come back with that cup of coffee, you'll have a
  new world to view, if not conquer.


  3D OVERLAY MODE

  While the <3> command creates its image on a blank screen, the <O>
  command draws a second image over an existing displayed image. This
  image can be any restored image from a <R> command or the result of a
  just executed <3> command. So you can do a landscape, then hit <O> and


                                       44

  choose spherical projection to re-plot that image or another as a moon
  in the sky above the landscape. <O> can be repeated as many times as
  you like.

  It's worth noting that not all that many years ago, one of us watched
  Benoit Mandelbrot and fractal-graphics wizard Dick Voss creating just
  such a moon-over-landscape image at IBM's research center in Yorktown
  Heights, NY. The system was a large and impressive mainframe with
  floating-point facilities bigger than the average minicomputer, running
  LBLGRAPH -- what Mandelbrot calls "an independent-minded and often very
  ill-mannered heap of graphics programs that originated in work by Alex
  Hurwitz and Jack Wright of IBM Los Angeles."

  We'd like to salute LBLGRAPH, its successors, and their creators,
  because it was their graphic output (like "Planetrise over Labelgraph
  Hill," plate C9 in Mandelbrot's "Fractal Geometry of Nature") that
  helped turn fractal geometry from a mathematical curiosity into a
  phenomenon. We'd also like to point out that it wasn't as fast, flexi-
  ble or pretty as FRACTINT on a 386/16 PC with S-VGA graphics. Now, a lot
  of the difference has to do with the incredible progress of micro-
  processor power since then, so a lot of the credit should go to Intel
  rather than to our highly tuned code. OK, twist our arms -- it IS
  awfully good code.


  SPECIAL NOTE FOR CGA OR HERCULES USERS

  If you are one of those unfortunates with a CGA or Hercules 2-color
  monochrome graphics, it is now possible for you to make 3D projection
  images.

  Try the following unfortunately circuitous approach. Invoke FRACTINT,
  making sure you have set askvideo=yes. Use a diskvideo mode to create a
  256 color fractal. You might want to edit the fractint.cfg file to make
  a diskvideo mode with the same pixel dimensions as your normal video
  (see "batch=config" command for how to create fractint.cfg). Using the
  "3" command, enter the file name of the saved 256 color file, say "no"
  to the "Legal for this machine?" prompt, selecting instead your 2 or 4
  color mode, and answer the other 3D prompts. You will then see a 3D
  projection of the fractal. Another example of Stone Soup responsiveness
  to our fan mail!


  MAKING TERRAINS

  If you enjoy using FRACTINT for making landscapes, we now have several
  new features for you to work with. When doing 3d transformations banding
  tends to occur because all pixels of a given height end up the same
  color. Now, colors can be randomized to make the transitions between
  different colors at different altitudes smoother. Use the new
  "RANDOMIZE= " variable to accomplish this. If your light source images
  all look like lunar landscapes since they are all monochrome and have
  very dark shadows, we now allow you to set the ambient light for
  adjusting the contrast of the final image. Use the "Ambient= " variable.
  In addition to being able to create scenes with light sources in


                                       45

  monochrome, you can now do it in full color as well. Setting fullcolor=1
  will generate a Targa-24 file with a full color image which will be a
  combination of the original colors of the source image (or map file if
  you select map=something) and the amount of light which reflects off a
  given point on the surface. Since there can be 256 different colors in
  the original image and 256 levels of light, you can now generate an
  image with *lots* of colors. To convert it to a GIF if you can't view
  Targa files directly, you can use PICLAB, and the following commands:

          SET PALETTE 256
          SET CREZ 8
          TLOAD yourfile.tga
          MAKEPAL
          MAP
          GSAVE yourfile.gif
          EXIT

  Using the full color option allows you to also set a haze factor with
  the "haze= " variable to make more distant objects more hazy.

  As a default, full color files also have the background set to sky blue.
  Warning, the files which are created with the full color option are very
  large, 3 bytes per pixel. So make sure to use a disk with enough space.
  The file is created using Fractint's disk-video caching, but is always
  created on real disk (expanded or extended memory is not used.)
  Try the following settings of the new variables in sequence to get a
  feel for the effect of each one:
          ;use this with any filltype
          map=topo
          randomize=3; adjusting this smoothes color transitions

          ;now add this using filltype 5 or 6
          ambient=20; adjusting this changes the contrast
          filltype=6
          smoothing=2; makes the light not quite as granular as the terrain

          ;now add the following, and this is where it gets slow
          fullcolor=1; use PICLAB to reduce resulting lightfile to a GIF

          ;and finally this
          haze=20; sets the amount of haze for distant objects

  When full color is being used, the image you see on the screen will
  represent the amount of light being reflected, not the colors in the
  final image. Don't be disturbed if the colors look weird, they are an
  artifact of the process being used. The image being created in the
  lightfile won't look like the screen.

  However, if you are worried, hit ESC several times and when FRACTINT
  gets to the end of the current line it will abort. Your partial image
  will be there as LIGHT001.TGA or with whatever file name you selected
  with the lightname option. Convert it as described above and adjust any
  parameters you are not happy with. Its a little awkward, but all we
  could do prior to this release.



                                       46


  HOW TO MAKE 3D SLIDES

  Bruce Goren, CIS's resident stereoscopic maven, contributed these tips
  on what to do with your 3D images (Bruce inspired and prodded us so much
  we automated much of what follows, allowing both this and actual on
  screen stereo viewing, but we included it here for reference and a brief
  tutorial.)

  "I use a Targa 32 video card and TOPAS graphic software, moving the
  viewport or imaginary camera left and right to create two separate views
  of the stationary object in x,y,z, space. The distance between the two
  views, known as the inter-ocular distance, toe-in or convergence angle,
  is critical. It makes the difference between good 3-D and headache-
  generating bad 3-D.

  "For a 3D fractal landscape, I created and photographed the left and
  right eye views as if flying by in an imaginary airplane and mounted the
  film chips for stereo viewing. To make my image, first I generated a
  plasma cloud based on a color map I calculated to resemble a geological
  survey map (available on CIS as TARGA.MAP). In the 3D reconstruction, I
  used a perspective value of 150 and shifted the camera -15 and +15 on
  the X-axis for the left and right views. All other values were left to
  the defaults.

  "The images are captured on a Matrix 3000 film recorder -- basically a
  box with a high-resolution (1400 lines) black and white TV and a 35mm
  camera (Konica FS-1) looking at the TV screen through a filter wheel.
  The Matrix 3000 can be calibrated for 8 different film types, but so far
  I have only used Kodak Ektachrome 64 daylight for slides and a few print
  films. I glass mount the film chips myself.

  "Each frame is exposed three times, once through each of the red, blue,
  and green filters to create a color image from computer video without
  the scan-lines which normally result from photographing television
  screens.  The aspect ratio of the resulting images led me to mount the
  chips using the 7-sprocket Busch-European Emde masks. The best source of
  Stereo mounting and viewing supplies I know of is an outfit called Reel
  3-D Enterprises, Inc. at P.O. Box 2368, Culver City, CA 90231, tel. 213-
  837-2368. "My platform is an IBM PC/AT crystal-swapped up to 9 MHz. The
  math co-processor runs on a separate 8-MHz accessory sub-board. The
  system currently has 6.5 MB of RAM."


  DISTANCE ESTIMATOR METHOD

  This is Phil Wilson's implementation of an alternate method for the M
  and J sets, based on work by mathematician John Milnor and described in
  "The Science of Fractal Images", p. 198.  While if takes full advantage
  of your color palette, one of the best uses is in preparing monochrome
  images for a printer.  Using the 1600x1200x2 disk-video mode and an HP
  LaserJet, we have produced pictures of quality equivalent to the black
  and white illustrations of the M-set in "The Beauty of Fractals."




                                       47

  The distance estimator method widens very thin "strands" which are part
  of the "inside" of the set.  Instead of hiding invisibly between pixels,
  these strands are made one pixel wide.

  To turn on the distance estimator method with any escape time type
  fractal, set the "distest" value on the <X> options screen to a nonzero
  value.  You should use 1 or 2 pass mode - solid guessing and boundary
  tracing can miss some of the thin strands made visible by distance
  estimator.  For the highest quality images, "maxiter" should also be set
  to a high value, say 1000 or so.  You'll probably also want "inside" set
  to zero, to get a black interior.

  In color modes, the distance estimator method also produces more evenly
  spaced contours.  Set "distest" to a higher value for narrower color
  bands, a lower value for wider ones.  1000 is a good value to start
  with.

  Setting "distest" automatically also toggles to floating point mode.
  When you reset distest back to zero, remember to also turn off floating
  point mode if you want it off.

  Unfortunately, images using the distance estimator method can take many
  hours to calculate even on a fast machine with a coprocessor, especially
  if a high "maxiter" value is used.  One way of dealing with this is to
  leave distest turned off while you find and frame an image.  Then hit
  <B> to save the coordinates to FRABATCH.BAT. Edit the batch file, adding
  "distest=1", "video=something" to select a high-resolution monochrome
  disk-video mode, "maxiter=1000", "inside=0" and "batch=yes".  (Watch out
  for the line exceeding the DOS limit of 120 characters - if it does, use
  "fractint @filename" in your batch and put the parameters in another
  file "filename".) Run the batch file when you won't be needing your
  machine (over the weekend?) and print the resulting .GIF file at your
  convenience.

  INVERSION

  Many years ago there was a brief craze for "anamorphic art": images
  painted and viewed with the use of a cylindrical mirror, so that  they
  looked weirdly distorted on the canvas but correct in the distorted
  reflection. (This byway of art history may be a useful defense when your
  friends and family give you odd looks for staring at fractal images
  color-cycling on a CRT.)

  The <I>nversion option performs a related transformation on most of the
  fractal types. You define the center point and radius of a circle;
  FRACTINT maps each point inside the circle to a corresponding point
  outside, and vice-versa. This is known to mathematicians as inverting
  (or if you want to get precise, "everting") the plane, and is something
  they can contemplate without getting a headache. John Milnor, mentioned
  earlier in connection with the distance-estimator method, made his name
  in the 1950s with a method for everting a seven-dimensional sphere, so
  we have a lot of catching up to do.

  For example, if a point inside the circle is 1/3 of the way from the
  center to the radius, it is mapped to a point along the same radial


                                       48

  line, but at a distance of (3 * radius) from the origin. An outside
  point at 4 times the radius is mapped inside at 1/4 the radius.

  The <I> command prompts you for the radius and center coordinates of the
  inversion circle. A default choice of -1 sets the radius at 1/6 the
  smaller dimension of the image currently on the screen.  The default
  values for Xcenter and Ycenter use the coordinates currently mapped to
  the center of the screen.

  Try this one out with a Newton plot, so its radial "spokes" will give
  you something to hang on to. Plot a Newton-method image, then hit <I>
  and use a radius of 1, default center coordinates. The center has
  "exploded" to the periphery.

  Inverting through a circle not centered on the origin produces bizarre
  effects that we're not even going to try to describe. Aren't computers
  wonderful?


  DECOMPOSITION

  You'll remember that most fractal types are calculated by iterating a
  simple function of a complex number, producing another complex number,
  until either the number exceeds some pre-defined "bailout" value, or the
  iteration limit is reached. The pixel corresponding to the starting
  point is then colored based on the result of that calculation.

  The decomposition command toggles to another coloring protocol. (It's
  <Q> because the first implementation was 4-way or "quaternary," and <D>
  was already spoken for.) Here the points are colored according to which
  quadrant of the complex plane (negative real/positive imaginary,
  positive real/positive imaginary, etc.) the final value is in. If you
  use 4 as the first parameter, points ending up in each quadrant are
  given their own color; if 2 (binary decomposition), points in alternat-
  ing quadrants are given 2 alternating colors.

  The result is a kind of warped checkerboard coloring, even in areas that
  would ordinarily be part of a single contour. Remember, for the M-set
  all points whose final values exceed 2 (by any amount) after, say, 80
  iterations are normally the same color; under decomposition, FRACTINT
  runs [bailout-value] iterations and then colors according to where the
  actual final value falls on the complex plane.

  The second parameter is the bailout value. The smaller it is, the faster
  (though not much) the plot will run; the larger it is, the more accurate
  it will be. A value of about 50 is a good compromise for M/J sets.

  LOGARITHMIC PALETTES

  By default, Fractint maps iterations to colors 1-1.  If you are using a
  16-color video mode, and you are using the default maximum iteration count
  of 150, your image will run through the 16-color palette 150/16 = 9.375
  times.  If you elect to use Logarithmic palettes, however, the color
  Fractint uses for iteration N will be determined by the algorithm
  "palettenumber = maxcolors * log(N) / log(maxiter).  This results in


                                       49

  spectacularly different images if you are using a high iteration limit
  near the current iteration maximum of 32000 and are zooming in on an area
  near a "lakelet".

  When using a logarithmic palette in a 256 color mode, we suggest changing
  your colors from the usual defaults.  The last few colors in the default
  IBM VGA color map are black.  This results in points nearest the "lake"
  smearing into a single dark band, with little contrast from the blue
  (by default) lake.

  BIOMORPHS

  Related to binary decomposition are the "biomorphs" invented by Clifford
  Pickover, and discussed by A. K. Dewdney in the July 1989 "Scientific
  American", page 110. These are so-named because this coloring scheme
  makes many fractals look like one-celled animals. The idea is simple.
  The escape-time algorithm terminates an iterating formula when the size
  of the orbit value exceeds a predetermined bail-out value. Normally the
  pixel corresponding to that orbit is colored according to the iteration
  when bailout happened. To create biomorphs, this is modified so that if
  EITHER the real OR the imaginary component is LESS than the bailout,
  then the pixel is set to the "biomorph" color. The effect is a bit
  better with higher bailout values: the bailout is automatically set to
  100 when this option is in effect. You can try other values with the
  "bailout=" option.  The biomorph option is turned on via the
  "biomorph=nnn" command-line option (where "nnn" is the color to use on
  the affected pixels).  When toggling to Julia sets, the default corners
  are three times bigger than normal to allow seeing the biomorph
  appendages. Does not work with all types -in particular it fails with
  any of the mandelsine family. However, if you are stuck with monochrome
  graphics, try it - works great in two-color modes. Try it with the
  marksmandel and marksjulia types, or any of the new "biomorph" fractals.


  STARFIELDS

  Once you have generated your favorite fractal image, you can convert it
  into a fractal starfield with the 'a' transformation (for 'astronomy'? -
  once again, all of the good letters were gone already).  Stars are
  generated on a pixel-by-pixel basis - the odds that a particular pixel
  will coalesce into a star are based (partially) on the color index of
  that pixel.

  (The following was supplied by Mark Peterson, the starfield author).

  If the screen were entirely black and the 'Star Density per Pixel' were
  set to 30 then a starfield transformation would create an evenly
  distributed starfield with an average of one star for every 30 pixels.

  If you're on a 320x200 screen then you have 64000 pixels and would end
  up with about 2100 stars.  By introducing the variable of 'Clumpiness' we
  can create more stars in areas that have higher color values.  At 100%
  Clumpiness a color value of 255 will change the average of finding a star
  at that location to 50:50.  A lower clumpiness values will lower the amount
  of probability weighting.  To create a spiral galaxy draw your favorite


                                       50

  spiral fractal (IFS, Julia, or Mandelbrot) and perform a starfield
  transformation.  For general starfields I'd recommend transforming a
  plasma fractal.

  Real starfields have many more dim stars than bright ones because very
  few stars are close enough to appear bright.  To achieve this effect the
  program will create a bell curve based on the value of ratio of Dim
  stars to bright stars.  After calculating the bell curve the curve is
  folded in half and the peak used to represent the number of dim stars.

  Starfields can only be shown in 256 colors.  FRACTINT will automatically
  try to load ALTERN.MAP and abort if the map file cannot be found.













































                                       51

  3. Command-Line Arguments, Batch Mode, and SSTOOLS.INI

  FRACTINT accepts command-line arguments that allow you to load it with
  your own choice of video mode, starting coordinates, and just about
  every other parameter and option. These arguments can also be included
  in a SSTOOLS.INI startup file, or in command files invoked on the
  command line using LINK-style syntax ("FRACTINT @MYFILE"). The program
  first looks along the DOS PATH for any file called SSTOOLS.INI and reads
  start-up variables from that file. Then, it looks at its own command
  line; arguments there will over-ride those from the .INI file. The
  syntax is:

                FRACTINT argument argument argument...

  where the individual arguments are separated by one or more spaces (an
  individual argument may NOT include spaces). Either upper or lower case
  may be used, and arguments can be in any order. To make your file more
  readable, you may replace the spaces with Returns.

  Some terminology:
  COMMAND=nnn               enter a number in place of "nnn"
  COMMAND=[filename]        you supply filename
  COMMAND=yes|no|whatever   means choose one of "yes", "no", and "whatever"
  COMMAND=1st[/2nd[/3rd]] - the slash-separated parameters "2nd" and
                            "3rd" are optional

  FILENAME=[name]
  Causes FRACTINT to read the named file, which must either have been
  saved from an earlier FRACTINT session (version 7.0 or later) or be a
  generic GIF file, and use that as its starting point, bypassing the
  initial information screens. The filetype is optional and defaults to
  *.GIF. Non-FRACTINT GIF files are restored as fractal type "plasma". On
  the command line you may omit FILENAME= and just give the name; the full
  argument is required in SSTOOLS.INI and other command files.

  @FILENAME
  Causes FRACTINT to read "filename" for arguments. When it finishes, it
  resumes reading its own command line -- i.e., "FRACTINT MAXITER=250
  @MYFILE PASSES=1" is legal. This option is only valid on the command
  line, as FRACTINT is not clever enough to deal with multiple
  indirection.

  PASSES=1|2|guess|btm
  Selects single-pass, dual-pass, solid-Guessing mode, or the Boundary
  Tracing algorithm.  Again, the first two take the same total time to
  finish the display, while solid-guessing is faster at the risk of errors
  for a few pixels.  Boundary tracing is sometimes faster, sometimes
  slower, and doesn't work for some fractal types at all (like the Newton
  fractals).








                                       52

  INSIDE=nnn|bof60|bof61|attractor
  Set the color of the interior: for example, "inside=0" makes the M-set a
  stylish basic black. A setting of -1 makes inside=maxiter. Two more options
  reveal hidden structure inside the lake.  These are inside=bof61, and
  inside=bof62, named after the figures on pages 61 and 62 of "Beauty of
  Fractals". See Appendix for a brilliant explanation of what these do!

  FINATTRACT=no|yes
  Another option to show coloring inside some Julia "lakes" to show escape
  time to finite attractors. Works with lambda, magnet types, and possibly
  others.  See appendix for more information.

  OUTSIDE=nnn
  Set the color of the exterior: for example, "OUTSIDE=1" makes all points
  not INSIDE the fractal set to color 1 (blue). Note that defining an
  OUTSIDE color forces any image to be a two-color one: either a point is
  INSIDE the set, or it's OUTSIDE it.

  MAXITER=nnn
  Reset the iteration maximum (the number of iterations at which the
  program gives up and says 'OK, this point seems to be part of the set in
  question and should be colored [insidecolor]') from the default 150.
  Values range from 10 to 32000 (super-high iteration limits like 30000
  are useful when using logarithmic palettes).

  BAILOUT=nnn
  Over-rides the default bailout criterion for escape-time fractals. Can
  also be set from the parameters screen after selecting a type.

  ITERINCR=nnn
  Set the iteration increment (the change in maxiter when you hit the '<'
  or '>' keys). Default is 50.

  VIDEO=xxx
  Set the initial video mode (and bypass the informational screens). Handy
  for batch runs. (Example: VIDEO=F4 for IBM 16-color VGA.)

  (You can obtain the current VIDEO= values from the "Video Modes" help
  screens inside Fractint.  We don't duplicate them here only because they
  change so darned often!)

  ASKVIDEO=yes|no
  If "no," this eliminates the prompt asking you if a file to be restored
  is OK for your current video hardware.

  WARNING: every version of FRACTINT so far has had a bigger, better, but
  shuffled-around video table. Since calling for a mode your hardware
  doesn't support can leave your system in limbo, be careful about leaving
  these arguments in a command file to be used with future versions of
  FRACTINT, particularly for the super-VGA modes.

  SAVENAME=[name]
  Set the filename to use when you <S>ave a screen. The default filename
  is FRACT001. The .GIF extension is optional (Example: SAVENAME=myfile)



                                       53

  WARN=yes|no
  Sets the savename warning flag (default is 'no'). If 'yes', saved files
  will NOT over-write existing files from previous sessions; instead the
  automatic incrementing of FRACTnnn.GIF will continue.

  SAVETIME=nnn
  Tells Fractint to automatically do a save every nnn minutes while a
  calculation is in progress.  This is mainly useful with long batches;
  see "Batch Mode" notes for more information.

  TYPE=[name]
  Selects the type of fractal image to display. The default is type
  "mandel," the M-set.

  PARAMS=n/n/n/n...
  Set optional (required, for some fractal types) values used in plotting.
  These numbers typically represent the real and imaginary portions of
  some startup value, and are described in detail as needed in Sec. 2.
  (Example: FRACTINT TYPE=julia PARAMS=-0.48/0.626 would wait at the
  opening screen for you to select a video mode, but then proceed straight
  to the Julia set for the stated x (real) and y (imaginary) coordinates.)

  CORNERS=xmin/xmax/ymin/ymax[/x3rd/y3rd]
  Example: corners=-0.739/-0.736/0.288/0.291
  Begin with these coordinates as the range of x and y coordinates, rather
  than the default values of (for type=mandel) -2.0/2.0/-1.5/1.5. When you
  specify four values (the usual case), this defines a rectangle: x-
  coordinates are mapped to the screen, left to right, from xmin to xmax,
  y-coordinates are mapped to the screen, bottom to top, from ymin to
  ymax. Six parameters can be used to describe any rotated or stretched
  parallelogram:  (xmin,ymax) are the coordinates used for the top-left
  corner of the screen, (xmax,ymin) for the bottom-right corner, and
  (x3rd,y3rd) for the bottom-left.

  CENTER-MAG=[Xctr/Yctr/Mag]
  This is an alternative way to enter corners as a center point and a
  magnification that is popular with some fractal programs and
  publications. Entering just "CENTER-MAG=" tells FRACTINT whether to use
  this form rather than corners when creating a batch file with the <B>
  command. The <TAB> status display now shows the "corners" in both forms.
  Note that an aspect ratio of 1.3333 is assumed; if you have altered the
  zoom box proportions or rotated the zoom box, this form can no longer be
  used.

  POTENTIAL=maxcolor[/slope[/modulus[/potfile]]]
  Establishes the "continuous potential" coloring mode for all fractal
  types except plasma clouds, IFS and IFS3D. The four arguments define the
  maximum color value, the slope of the potential curve, the modulus
  "bailout" value, and the savefile name. Example: "POTENTIAL=
  240/2000/40/potfile". The Mandelbrot and Julia types ignore the modulus
  bailout value and use their own hardwired value of 4.0 instead; see Sec.
  4 on the continuous-potential algorithm for details.





                                       54

  RSEED=nnnn
  The initial random-number "seed" for plasma clouds is taken from your
  PC's internal clock-timer. This argument forces a value (which you can
  see in the <Tab> display), and allows you to reproduce plasma clouds. A
  detailed discussion of why a TRULY random number may be impossible to
  define, let alone generate, will have to wait for "FRACTINT: The 3-MB
  Doc File."

  DECOMP=2|4|8|16|32|64|128|256
  Invokes the corresponding decomposition coloring scheme.

  DISTEST=nnn
  Nonzero values enable the distance estimator method. Any nonzero value
  has the same effect in monochrome modes. Higher values result in more
  and narrower color bands in color modes; 1000 is a good value to try.

  LOGMAP=yes|old
  Normally escape-time iterations are mapped one-to-one to palette colors,
  which causes areas with a high iteration count to lose detail. Turning
  this option on causes colors to be mapped to the logarithm of the
  iteration, revealing structure in the "gravel".  This command has been
  updated with an improved algorithm as of version 14.  To use the old
  method, enter "logmap=old".

  IFS=[filename]
  Use the IFS coded values in [filename] to generate Barnsley IFS
  fractal images. The default extension is .IFS. See Sec. 2 for details.

  IFS3D=[filename]
  Use the IFS coded values in [filename] to generate Barnsley IFS3D
  fractals.

  3D=Yes
  Resets all 3d parameters to default values, as described in Sec. 2.
  If FILENAME= is given, forces the restore to be performed in 3D mode.
  Very handy when used with the 'batch=yes' option for batch-mode 3D
  images. If 3D=Yes follows the setting of any 3d parameters on the
  command line or in a command file, they will be reset to default
  values. (Note: the form "3D/=parm/parm/parm ..." for entering 3D
  parameters still works but will not be supported in the future. Use
  the variables below. Position-sensitive parameters are nasty and evil,
  especially when there are dozens of them!)

  The options below replace selected 3D defaults:
  SPHERE=yes                 Turns on spherical projection mode
  LONGITUDE=nn/nn            Longitude minimum and maximum
  LATITUDE=nn/nn             Latitude minimum and maximum
  RADIUS=nn                  Radius scale factor
  ROTATION=nn[/nn[/nn]]      Rotation about x,y, and z axes
  SCALEZYZ=nn/nn/nn          X,y,and z scale factors
  ROUGHNESS=nn               Same as z scale factor
  WATERLINE=nn               Colors nn and below will be "inside" color
  FILLTYPE=nn                3D filltype
  PERSPECTIVE=nn             Perspective distance



                                       55

  XYSHIFT=nn/nn              Shift image in x and y directions with
                              perspective
  LIGHTSOURCE=nn/nn/nn       Coordinates for light-source vector
  SMOOTHING=nn               Smooths images in light-source fill modes
  TRANSPARENT=min/max        Defines a range of colors to be treated as
                              "transparent" when <O>verlaying 3D images.
  XYADJUST=nn/nn             This shifts the image in the x/y dir without
                              perspective
  STEREO=n                   Selects the type of stereo image creation
  INTEROCULAR=nn             Sets the interocular distance for stereo
  CONVERGE=nn                Determines the overall image separation
  CROP=nn/nn/nn/nn           Trims the edges off stereo pairs
  BRIGHT=nn/nn               Compensates for funny glasses filter parameters

  Below are new commands as of version 14 that support Marc Reinig's
  terrain features.

  RANDOMIZE=nnn  (0 - 100)
  This feature randomly varies the color of a pixel to near by colors. Useful
  to minimize map banding in 3d transformations. Usable with all FILLTYPES. 0
  disables, max values is 7. Try 3 - 5.

  AMBIENT=nnn (0 - 100)
  Set the depth of the shadows when using full color and light source
  filltypes. "0" disables the function, higher values lower the contrast.

  FULLCOLOR=yes
  Valid with any light source FILLTYPE. Allows you to create a Targa-24 file
  which uses the color of the image being transformed or the map you select
  and shades it as you would see it in real life. Well, its better than BW. A
  good map file to use is topo


  HAZE=nnn (0 - 100)
  Gives more realistic terrains by setting the amount of haze for distant
  objects when using full color in light source FILLTYPES. Works only in the
  "y" direction currently, so don't use it with much y rotation. Try
  "rotation=85/0/0". 0 disables.


  LIGHTNAME=<filename>
  The name of the Targa-24 file to be created when using full color with
  light source. Default is light001.tga. If warn=yes the file name will be
  incremented. Background in this file will be sky blue.

  To stay out of trouble, use the complete list, even if you want to use
  what you think are the default values. It takes a little practice to
  learn what the default values really are. The best way to create a
  command file is to use the Batch command <B> on an image you like and
  then modify the resulting parameters.







                                       56

  INVERT=nn/nn/nn
  Turns on inversion. The parameters are radius of inversion, x-coordi-
  nate of center, and y-coordinate of center. -1 as the first parameter
  sets the radius to 1/6 the smaller screen dimension; no x/y parameters
  defaults to center of screen. The values are displayed with the <Tab>
  command.

  FLOAT=yes
  Most fractal types have both a fast integer math and a floating point
  version. The faster, but possibly less accurate, integer version is the
  default. If you have a new 80486 or other fast machine with a math
  coprocessor, or if you are using the continuous potential option (which
  looks best with high bailout values not possible with our integer math
  implementation), you may prefer to use floating point. Just add "float=yes"
  to the command line to do so.

  PRINTER=type[/resolution[/port#]]
  Defines your printer setup. Currently legal printer types (only the
  first two characters are needed): [HP] LaserJet, [EP]son-compatible,
  [IB]M-compatible (which is identical to the Epson driver at the
  moment), [CO]lor (equivalent to the Star Micronics printer, which
  is supposedly epson-color-compatible), and [PA]intjet.
  The default printer type is the Epson/IBM. Resolution is in
  DPI, and currently available values are 60, 120, and 240 for the
  Epson/IBM and 75, 150, and 300 for the LaserJet (the default value is
  the lowest resolution). Legal printer port values are 1, 2, and 3 (for
  LPT 1-3) and 11, 12, 13, and 14 (for COM1-4). The SSTOOLS.INI file is a
  REAL handy place to put this option, so that it's available whenever
  you have that sudden, irresistible urge for hard copy.

  CYCLELIMIT=nnn
  Sets the speed of color cycling. Technically, the number of DAC regis-
  ters updated during a single vertical refresh cycle. Legal values are 1
  - 256, default is 55.

  MAP=[filename]
  Reads in a replacement color map from [filename]. This map replaces the
  default video color map of your VGA or TARGA card. The file must be in
  the format described in Sec. 4. The difference between this argument
  and an alternate map read in via <M> in color-command mode is that this
  one is permanent. WARNING: If colors 0 and 1 decode to the same color,
  your help screens will use the same color for both text and back-
  ground, which makes them kind of difficult to read.

  FORMULAFILE=[formulafilename]
  Lets you specify the default formula file for type=formula fractals
  (the default is FRACTINT.FRM).  Handy if you want to generate one
  of these fractal types in batch mode.

  FORMULANAME=[formulaname]
  Lets you specify the default formula name for type=formula fractals
  (the default is no formula at all).  Required if you want to generate
  one of these fractal types in batch mode, as this is the only way to
  specify a formula name in that case.



                                       57

  ;
  As usual, indicates the rest of the command line (or the rest of the
  individual line inside command files) is a comment.

  SOUND=off|x|y|z
  We're all MUCH too busy to waste time with FRACTINT at work, and no doubt
  you are too, so "sound=off" included only for use at home, to avoid waking
  the kids or your Significant Other, late at night. (By the way, didn't you
  tell yourself "just one more zoom on LambdaSine" an hour ago?) Suggestions
  for a "boss" hot-key will be cheerfully ignored, as this sucker is getting
  big enough without including a spreadsheet screen too. The "sound=x/y/x"
  options are for the "attractor" fractals, like the Lorenz fractals - they
  play with the sound on your PC speaker as they are generating an image,
  based on the X or Y or Z co-ordinate they are displaying at the moment.  At
  the moment, "sound=x" (or y or z) really doesn't work very well when using
  an integer algorithm - try it with the floating-point toggle set, instead.

  HERTZ=nnn
  Adjusts the sound produced by the "sound=x/y/z" option.  Legal values
  are 200 through 10000.

  BATCH=config
  Starts a quick batch-mode run that creates a default FRACTINT.CFG file
  from the full internal video table (FRACTINT.CFG is described in Sec. 5).

  FUNCTION=[fn1[/fn2[/fn3[/fn4]]]]
  Allows setting variable functions found in some fractal type formulae.
  Possible values are sin, cos, sinh, cosh, exp, log, and sqr.

  PERIODICITY=no|show|nnn
  Allows control of periodicity checking.  "no" turns it off, "show" lets
  you see which pixels were painted the "inside" color due to being caught
  by periodicity.  Specifying a number causes a more conservative
  periodicity test (each increase of 1 divides the test tolerance by 2).
  Entering a negative number lets you turn on "show" with that number.
  Type lambdafn function=exp needs periodicity turned off to be
  accurate -- there may be other cases.

  INITORBIT=pixel
  INITORBIT=nnn/nnn
  Allows control over the value used to begin each Mandelbrot-type orbit.
  "initorbit=pixel" is the default for most types; this command initializes
  the orbit to the complex number corresponding to the screen pixel. The
  command "initorbit=nnn/nnn" uses the entered value as the initializer. See
  the discussion of the MANDELLAMBDA type for more on this topic.
  allows changing the initialization of types that do not use lo

  GIF87a=YES
  Backward-compatibility switch to force creation of GIF files in the GIF87a
  format.  As of version 14, FRACTINT now defaults to the new GIF89a format
  which permits storage of fractal information within the format. This switch
  is only needed if you wish to view FRACTINT images with a GIF decoder that
  cannot accept the newer format.




                                       58

     BATCH MODE

  It IS possible, believe it or not, to become so jaded with the screen
  drawing process, so familiar with the types and options, that you just
  want to hit a key and do something else until the final images are safe
  on disk.  To do this, start Fractint with the BATCH=yes parameter added
  to the command line.  To create a batch file with the parameters
  required for a particular image you might:
    o Find an interesting area.  Note the parameters from the <Tab>
      display.  Then use an editor to write a batch file.
    o Find an interesting area.  Set all the parameters you'll want
      in the batch run.  Use the <B> command to store the parameters
      in FRABATCH.BAT.  Then use an editor to add the required batch
      mode parameters to the generated FRABATCH.BAT line.
  A different approach to batch mode calculations, using "FILENAME="
  and resume, is described below.

  When modifying a command line generated by the <B> command, the
  only parameters you must add for a batch mode run are "BATCH=yes",
  and "VIDEO=xxx" to select a video mode.  You might want to also add
  "SAVENAME=[name]" to name the result as something other than the
  default FRACT001.GIF.  Watch out for the line exceeding the DOS
  limit of 120 characters - if it does, use "fractint @filename" in
  your batch and put the parameters in another file "filename".

  "BATCH=yes" tells Fractint to run in batch mode -- that is, Fractint
  draws the image using whatever other parameters you specified, then
  acts as if you had hit <S> to save the image, then exits to DOS.

  "FILENAME=" can be used with "BATCH=yes" to resume calculation of an
  incomplete image.  For instance, you might interactively find an image
  you like; then select some slow options (a high resolution disk video
  mode, distance estimator method, high maxiter, or whatever);  start
  the calculation;  then interrupt immediately with a <S>ave.  Rename
  the save file (fract001.gif if it is the first in the session and
  you didn't name it with the <X> options or "savename=") to xxx.gif.
  Later you can run a batch file to finish the job:
      fractint batch=yes filename=xxx savename=xxx

  "SAVETIME=nnn" is useful with long batch calculations, to store a
  checkpoint every nnn minutes.  If you start a many hour calculation
  with say "savetime=60", and a power failure occurs during the
  calculation, you'll have lost at most an hour of work on the image.
  You can resume calculation from the save file as above.  Automatic
  saves triggered by SAVETIME do not increment the save file name. The
  same file is overwritten by each auto save until the image completes.
  But note that Fractint does not directly over-write save files.
  Instead, each save operation writes a temporary file FRACTINT.TMP,
  then deletes the prior save file, then renames FRACTINT.TMP to be
  the new save file.  This protects against power failures which occur
  during a save operation - if such a power failure occurs, the prior
  save file is intact and there's a harmless incomplete FRACTINT.TMP
  on your disk.




                                       59

  If you want to spread a many-hour image over multiple bits of free
  machine time you could use a batch like:
      fractint batch=yes filename=xxx savename=xxx savetime=60
  While this batch is running, hit <S> (almost any key actually) to tell
  fractint to save what it has done so far and give your machine back.
  Kick off the batch again when you have another time slice for it.

  The SAVETIME= parameter, and batch resumes of partial calculations,
  only work with fractal types which can be resumed.  See "Interrupting
  and Resuming" for information about non-resumable types.


  SSTOOLS.INI

  If you are familiar with Microsoft's TOOLS.INI or WINDOWS.INI configu-
  ration files, the SSTOOLS.INI command file is used in the same way. In
  particular, you designate a section of SSTOOLS.INI as belonging to a
  particular program by beginning the section with a label in brackets.
  FRACTINT looks for the label [fractint], and ignores any lines it finds
  in the file belonging to any other label. If an SSTOOLS.INI file looks
  like this:

  [fractint]
  sound=off                    ; (for home use only)
  printer=hp                   ; my printer is a LaserJet
  [startrek]
  Aye, captain, but I dinna think the engines can take it!
  [fractint]
  inside=0                     ; using "traditional" black

  FRACTINT will use only the second, third, and last lines.

  (Why use a convention like that when FRACTINT is the only program
  you know of that uses an SSTOOLS.INI file?  Because there are other
  programs (such as Lee Crocker's PICLAB) that now use the same file, and
  people working on other, sister programs to FRACTINT are going to read
  that file. And just when you thought it was safe to download again..!)




















                                       60

  4. File Formats, Color Maps and All That

  FRACTINT AND .GIF FILES

  Since version 5.0, FRACTINT has had the <S>ave-to-disk command, which
  stores screen images in the extremely compact, flexible .GIF (Graphics
  Interchange Format) widely supported on Compuserve. Version 7.0 added
  the <R>estore-from-disk capability. Unfortunately, this created a
  problem. The then-current GIF87a specification did not offer a place
  to store the small amount of extra information that FRACTINT needs in
  order to implement the <R> feature -- i.e., the parameters that let you
  keep zooming, etc. so on as if the restored file had just been created
  in this session.

  FRACTINT got around this restriction in a non-standard manner, saving
  its application-specific information AFTER the official GIF terminator
  character. This trick worked with all of the popular GIF decoders that
  we had tested (although some of them required renaming the file to
  xxxx.GIF first).

  We did not claim that these files are true GIF files. For one thing,
  information after the GIF terminator has the potential to confuse the
  on-line GIF viewers used on Compuserve. For another, it is the opinion
  of some GIF developers that the addition of this extra information violates
  the GIF87a spec. That's why we used the default filetype .FRA instead.

  On August 1, 1990, Compuserve released an official upwardly-compatible
  extension of the GIF87a spec, called GIF89a.  This new spec allows the
  placement of application data within "extension blocks". FRACTINT version
  14 supports the new spec. We have changed default savename extension from
  *.FRA to *.GIF.  Version 14 can still read *.FRA files generated by earlier
  versions.  If for some reason you wish to save files in the older GIF87a
  format, because, for example, your favorite GIF decoder has not yet been
  upgraded to GIF89a, just add the command-line parameter "GIF87a=yes".  Then
  any saved files will use the original GIF87a format without any
  application-specific information.

  An easy way to convert an older .FRA file into true .GIF format suitable
  for uploading is something like this at the DOS prompt:

  FRACTINT MYFILE.FRA SAVENAME=MYFILE.GIF BATCH=YES

  FRACTINT will load MYFILE.FRA, save it in true .GIF format as MYFILE.GIF,
  and return to DOS.

  There is one significant advantage to the new GIF89a format compared to the
  old GIF87a-based .FRA format for FRACTINT purposes:  the new .GIF files may
  be uploaded to the Compuserve graphics forums (such as FRACTINT's home
  forum, COMART) with fractal information intact.  Therefore anyone
  downloading a FRACTINT image from Compuserve will also be downloading all
  the information needed to re-generate the image.

  GIF and "Graphics Interchange Format" are trademarks of Compuserve
  Incorporated, an H&R Block Company.



                                       61

  CONTINUOUS POTENTIAL

  FRACTINT's images are usually calculated by the "level set" method,
  producing bands of color corresponding to regions where the calculation
  gives the same value. When viewed in 3D, most images other than plasma
  clouds are like terraced landscapes: most of the surface is either
  horizontal or vertical.

  To get the best results with the "illuminated" 3D fill options 5 and 6,
  there is an alternative approach that yields continuous changes in
  colors. A 256-color MCGA/VGA video mode is mandatory to appreciate this
  effect (it's hard to show continuous variation with only 4 or 16
  colors!)

  Continuous potential is approximated by calculating

           potential =  log(modulus)/2^iterations

  where "modulus" is the orbit value (magnitude of the complex number)
  when the modulus bailout was exceeded, at the "iterations" iteration.
  Clear as mud, right?

  Fortunately, you don't have to understand all the details. However,
  there ARE a few points to understand. First, FRACTINT's criterion for
  halting a fractal calculation, the "modulus bailout value", is general-
  ly set to 4. Continuous potential is inaccurate at such a low value.

  The bad news is that the integer math which makes the "mandel" and
  "julia" types so fast imposes a hard-wired maximum value of 127. You
  can still make interesting images from those types, though, so don't
  avoid them. You will see "ridges" in the "hillsides." Some folks like
  the effect.

  The good news is that the other fractal types, particularly the
  (generally slower) floating point algorithms, have no such limitation.
  The even better news is that there is a floating-point algorithm for
  the "mandel" and "julia" types.  To force the use of a floating-point
  algorithm, use Fractint with the "FLOAT=YES" command-line toggle.  Only
  a few fractal types like plasma clouds, the Barnsley IFS/IFS3d types,
  and "test" are unaffected by this toggle.

  The parameters for continuous potential are:
      potential=maxcolor[/slope[/modulus[/potfile]]]

  "Maxcolor" is the color corresponding to zero potential, which plots as
  the TOP of the mountain. Generally this should be set to one less than
  the number of colors, e.g. 255 for VGA. Remember that the last few
  colors of the default IBM VGA palette are BLACK, so you won't see what
  you are really getting unless you change to a different palette.

  "Slope" affects how rapidly the colors change -- the slope of the
  "mountains" created in 3D. If this is too low, the palette will not cover
  all the potential values and large areas will be black. If it is too high,
  the range of colors in the picture will be much less than those available.
  There is no easy way to predict in advance what these values should be.


                                       62


  "Modulus" is the bailout value used to determine when an orbit has
  "escaped". Larger values give more accurate and smoother potential. A
  value of 500 gives excellent results. As noted, this value must be
  <128 for the integer fractal types (if you select a higher number, they
  will use 127).

  "Potfile" is a filename to store the potential image in compressed
  TARGA format, with 16 bits per pixel. If you save the image in the
  normal way and then view it in 3D, the illumination modes 5 and 6 will
  work fine, but the colors will look a bit granular. This is because
  even with 256 colors, the continuous potential is being truncated to
  integers. If the "potfile" parameter is given, much smoother pictures
  can be obtained. But beware: even these compressed files still use up
  to 2 bytes per pixel, so they can get quite large.

  The following commands can be used to recreate the image that Mark
  Peterson first prototyped for us, and named "MtMand":

                  TYPE=mandel
                  CORNERS=-0.19920/-0.11/1.0/1.06707
                  INSIDE=255
                  MAXITER=255
                  POTENTIAL=255/2000/1000/potfile.tga
                  PASSES=1
                  FLOAT=yes

  This assumes a 256-color video mode.


  PALETTE MAPS

  If you have a VGA, Super-VGA, 8514/A, or TARGA video adapter, you can
  save and restore your color palette using special color-map files
  and either the command-line "map=" option, or the "D", "A", "S",
  and "M" color-cycling mode commands.  These color-maps are ASCII files
  set up as a series of RGB triplet values (one triplet per line,
  encoded as the red, green, and blue [RGB] components of the color).
  Note that the color values are in TARGA/GIF format - values go from
  0 (low) to 255 (high), so for a VGA adapter they get divided by 4
  before being stuffed into the VGA's Video-DAC registers (so '6'
  and '7' end up referring to the same color value).  The default
  filetype for color-map files is ".MAP".

  The distribution file contains sample .MAP files for you to examine
  and modify - DEFAULT.MAP (the VGA start-up values), ALTERN.MAP
  (the famous "Peterson-Vigneau Pseudo-Grey Scale"), GAMMA1.MAP and
  GAMMA2.MAP (Lee Crocker's response to ALTERN.MAP), LANDSCAP.MAP
  (Guruka Singh Khalsa's favorite color-map for plasma "landscapes"),
  TOPO.MAP (Monte Davis's contribution to full color terrain), and
  GRID.MAP (great for stereo surface grid images).






                                       63

  5. Hardware Support

  True to the spirit of public-domain programming, FRACTINT makes only a
  limited attempt to verify that your video adapter can run in the mode you
  specify, or even that an adapter is present, before writing to it.
  Hence the warning to check your "VIDEO=" argument before using a new
  version, in which the old key combo may now call an ultraviolet
  holographic mode.

  FRACTINT also assumes that every EGA adapter has a full 256K of memory
  (and can therefore display 640 x 350 x 16 colors), but does nothing to
  verify that fact before slinging pixels.


  NOTES ON MODES, "STANDARD" AND OTHERWISE

  FRACTINT uses a video adapter table in the "C" program for everything
  it needs to know about any particular adapter/mode combination. This
  table can contain information for up to 98 adapter/mode combinations,
  and is automatically tied to 84 keys (F2-F10, their Control/ Shift/Alt
  variants, and many Alt-x keypad combos) when the program is running.
  The table entries, and the function keys they are tied to, are displayed
  as part of the help screens.

  This table makes adding support for various third-party video cards and
  their modes much easier, at least for the ones that pretend to be a
  standard adapter with more dots and/or colors. There is even a special
  "roll-your-own" video mode (mode 19) enabling those of you with "C"
  compilers and a copy of the FRACTINT source to generate video modes
  supporting whatever adapter you may have. You can customize the table
  using the external configuration file FRACTINT.CFG, described below.

  The table as currently distributed begins with nine standard and
  several non-standard IBM video modes that have been exercised success-
  fully with a PS/2 model 80. These entries, coupled with the descriptive
  comments in the table definition and the information supplied (or that
  should have been supplied!) with your video adapter, should be all you
  need to add your own entries.


  320 x 400 x 256 and 360 x 480 x 256 VGA MODES
  The IBM VGA adapter is a highly programmable device, and can be set up
  to display many video-mode combinations beyond those "officially"
  supported by the IBM BIOS. These video modes are perfectly legal, but
  temporarily reprogram the adapter (IBM or fully register-compatible) in
  a non-standard manner that the BIOS does not recognize. Because of
  this, the program cannot send any text to the screen while it is in one
  of these modes (the BIOS would garbage it). An internal flag inhibits
  all text output while the screen is in one of these video modes.
  FRACTINT's <F1> (help) and <Tab> commands still work, because they
  temporarily switch the screen to an alternate video mode.






                                       64

  8514/A MODES

  The IBM 8514/A modes use IBM's software interface, and require the pre-
  loading of IBM's HDIDLOAD TSR utility. There are two sets of 8514/A
  modes: full sets (640x480, 1024x768) which cover the entire screen and
  do NOT have a border color (so that you cannot tell when you are
  "paused" in a color-cycling mode), and partial sets (632x474, 1016x762)
  with small border areas which do turn white when you are paused in
  color-cycling mode. Also, while these modes are declared to be 256-
  color, if you do not have your 8514/A adapter loaded with its full
  complement of memory you will actually be in 16-color mode. Finally,
  because IBM's interface does not handle drawing single pixels very well
  (we have to draw a 1x1 pixel "box"), generating the zoom box is
  excruciatingly slow. Still, it works!


  SUPER-EGA AND SUPER-VGA MODES
  After the IBM and quasi-pseudo-demi-IBM modes, the table contains an
  ever-increasing number of entries for other adapters. Almost all of
  these entries have been added because someone like you sent us spec
  sheets, or modified FRACTINT to support them and then informed us about
  it.  With version 12.0, we've added both John Bridges' SuperVGA
  Autodetecting logic *and* VESA adapter detection, so that many of the
  brand-specific SuperVGA modes have been collapsed into a single function
  key.  There is now exactly one function key for SuperVGA 640x480x256
  mode, for instance.

  TARGA MODES
  TARGA support for FRACTINT is provided courtesy of Joe McLain. Be aware
  that there are a LOT of possible TARGA configurations, and a LOT of
  opportunities for a TARGA board and a VGA or EGA board to interfere
  with each other, and we may not have all of them smoothed away yet.
  Also, the TARGA boards have an entirely different color-map scheme than
  the VGA cards, and at the moment they cannot be run through the color-
  cycling menu. The "MAP=" argument (Sec. 3), however, works with both
  TARGA and VGA boards and enables you to redefine the default color maps
  with either board.

  "DISK-VIDEO" MODES
  These "video modes" do not involve a video adapter at all. They use (in
  order or preference) your expanded memory, your extended memory, or your
  disk drive (as file FRACTINT.DSK) to store the fractal image. These
  modes are useful for creating images beyond the capacity of your video
  adapter, right up to the current internal limit of 2048 x 2048 x 256,
  and for background processing under multi-tasking DOS managers.

  While you are in a disk-video mode, your screen will display text
  information indicating whether memory or your disk drive is being used,
  and what portion of the "screen" is being read from or written to.  A
  "Cache size" figure is also displayed. 24K is the maximum cache size.
  If you see a number less than this, it means that you don't have a lot
  of memory free, and that performance will be less than optimum.  With
  a very low cache size such as 4 or 6k, performance gets considerably
  worse in cases using solid guessing, boundary tracing, plasma, or
  anything else which paints the screen non-linearly.  If you have this


                                       65

  problem, all we can suggest is having less TSR utilities loaded before
  starting Fractint, or changing in your config.sys file, such as reducing
  a very high BUFFERS value.

  The zoom box is disabled during disk-video modes (you couldn't see where
  it is anyway).  So is the orbit display feature.

  When using real disk for your disk-video, Fractint will not generate
  some "attractor" types (e.g. lorenz) nor "IFS" images.  These would kill
  your disk drive.  Boundary tracing is allowed - it may give your drive
  a bit of a workout, but is generally tolerable.

  When using a real disk, and you are not directing the file to a ram
  disk, and you aren't using a disk caching program on your machine,
  specifying BUFFERS=10 (or more) in your config.sys file is best for
  performance.  BUFFERS=10,2 or even BUFFERS=10,4 is also good.  It is
  also best to keep your disk relatively "compressed" (or "defragmented")
  if you have a utility to do this.

  In order to use extended memory, you must have himem.sys or an
  equivalent that supports the XMS 2.0 standard or higher.  Also, you
  can't have a VDISK installed in extended memory.  Himem.sys is
  distributed with Microsoft Windows 286/386 and 3.0.  If you have
  problems using the extended memory, try rebooting with just himem.sys
  loaded and see if that clears up the problem.

  If you are running background disk-video fractals under Windows 3, and you
  don't have a lot of real memory (over 2Mb), you might find it best to force
  Fractint to use real disk for disk-video modes.  (Force this by using a
  if your disk goes crazy when generating background images, which are
  supposedly using extended or expanded memory.  This problem can occur
  because, to multi-task, sometimes Windows must page an application's
  expanded or extended memory to disk, in big chunks. Fractint's own cached
  disk access may be faster in such cases.

  "TWEAKED" VGA MODES
  FRACTINT contains code that sets up the IBM (or any truly register-
  compatible) VGA adapter for several extended modes such as 704x528,
  736x552, 768x576, and 800x600. It does this by programming the VGA
  controller to use the fastest dot-clock on the IBM adapter (28.322 MHz),
  throwing more pixels, and reducing the refresh rate to make up for it.

  These modes push many monitors beyond their rated specs, in terms of both
  resolution and refresh rate. Signs that your monitor is having problems
  with a particular "tweaked" mode include:

  * vertical or horizontal overscan (displaying dots beyond the edges of
    your visible CRT area)

  * flickering (caused by a too-slow refresh rate)

  * vertical roll or total garbage on the screen (your monitor simply can't
    keep up, or is attempting to "force" the image into a pre-set mode that
    doesn't fit).



                                       66

  We have successfully tested the modes up to 768x576 on an IBM PS/2
  Model 80 connected to IBM 8513, IBM 8514, NEC Multisync II, and Zenith
  1490 monitors (all of which exhibit some overscan and flicker at the
  highest rates), and have tested 800x600 mode on the NEC Multisync II
  (although it took some twiddling of the vertical-size control).

  FRACTINT.CFG

  If you have a favorite adapter/video mode that you would like to add to
  FRACTINT... if you want to remove table entries that do not apply to
  your system... if you're bothered that your favorite mode requires the
  <Alt><Left-Shift><Swizzlestick> key combination... or if you are using
  a non-enhanced keyboard so that you can't USE that combination...
  relief is here, and without even learning "C"!

  FRACTINT will create an external, editable video configuration file
  called FRACTINT.CFG, and from then on will use that instead of its
  internal table as long as it can locate it somewhere along the DOS
  path. Enter FRACTINT BATCH=CONFIG, and you will get a default file with
  an entry for every one of the internal video table entries, and you can
  go to work on it with a text editor.

  Any line in the file that begins with a tab or a space (or is empty) is
  treated as a comment. The rest of the lines must consist of ten fields
  separated by commas. The ten fields are defined as:

  1. The name of the adapter/video mode (25 chars max, no leading
  blanks). The adapter is set up for that mode via INT 10H, with:
  2. AX = this,
  3. BX = this,
  4. CX = this, and
  5. DX = this (hey, having all these registers wasn't OUR idea!)
  6. An encoded value describing how to write to your video memory in
  that mode. Currently available codes are:
    1) Use the BIOS (INT 10H, AH=12/13, AL=color) (last resort - SLOW!)
    2) Pretend it's a (perhaps super-res) EGA/VGA
    3) Pretend it's an MCGA
    4) SuperVGA 256-Color mode using the Tseng Labs chipset
    5) SuperVGA 256-Color mode using the Paradise chipset
    6) SuperVGA 256-Color mode using the Video-7 chipset
    7) Non-Standard IBM VGA 360 x 480 x 256-Color mode
    8) SuperVGA 1024x768x16 mode for the Everex chipset
    9) TARGA video modes
   10) HERCULES video mode
   11) Non-Video, i.e. "disk-video"
   12) 8514/A video modes
   13) CGA 320x200x4-color and 640x200x2-color modes
   14) Reserved for Tandy 1000 video modes
   15) SuperVGA 256-Color mode using the Trident chipset
   16) SuperVGA 256-Color mode using the Chips & Tech chipset
   17) SuperVGA 256-Color mode using the ATI VGA Wonder chipset
   18) SuperVGA 256-Color mode using the EVEREX chipset
   19) Roll-your-own video mode (as you've defined it in YOURVID.C)
   20) SuperVGA 1024x768x16 mode for the ATI VGA Wonder chipset
   21) SuperVGA 1024x768x16 mode for the Tseng Labs chipset


                                       67

   22) SuperVGA 1024x768x16 mode for the Trident chipset
   23) SuperVGA 1024x768x16 mode for the Video 7 chipset
   24) SuperVGA 1024x768x16 mode for the Paradise chipset
   25) SuperVGA 1024x768x16 mode for the Chips & Tech chipset
   26) SuperVGA 1024x768x16 mode for the Everex Chipset
   27) SuperVGA Auto-Detect mode (we poke around looking for your adapter)
   28) VESA modes

  7. The number of pixels across the screen (X - 160 to 2048)
  8. The number of pixels down the screen (Y - 160 to 2048)
  9. The number of available colors (2, 4, 16, or 256)
  10. A comment describing this mode (25 chars max, leading blanks are OK)

  NOTE that the AX, BX, CX, and DX fields are generated (and read back)
  using hexadecimal notation (fifteen ==> 'f', sixteen ==> '10'), because
  that's the way most adapter documentation describes it. The other
  fields use standard decimal notation.

  If you look closely at the default entries, you will notice that the
  IBM VGA entries labeled "tweaked" and "non standard" have entries in
  the table with AX = BX = CX = 0, and DX = some other number. Those are
  special flags that we used to tell the program to custom-program the
  VGA adapter, and are NOT undocumented BIOS calls. Maybe they should be,
  but they aren't.

  If you have a fancy adapter and a new video mode that works on it, and
  it is not currently supported, PLEASE GET THAT INFORMATION TO US!  We
  will add the video mode to the list on our next release, and give you
  credit for it. Which brings up another point: If you can confirm that a
  particular video adapter/mode works (or that it doesn't), and the
  program says it is UNTESTED, please get that information to us also.
  Thanks in advance!

























                                       68

  6. Fractals and the PC


  A LITTLE HISTORY

  Like new forms of life, new branches of mathematics and science don't
  appear from nowhere. The ideas of fractal geometry can be traced to the
  late nineteenth century, when mathematicians created shapes -- sets of
  points -- that seemed to have no counterpart in nature.  By a wonderful
  irony, the "abstract" mathematics descended from that work has now turned
  out to be MORE appropriate than any other for describing many natural
  shapes and processes.

  Perhaps we shouldn't be surprised.  The Greek geometers worked out the
  mathematics of the conic sections for its formal beauty; it was two
  thousand years before Copernicus and Brahe, Kepler and Newton overcame the
  preconception that all heavenly motions must be circular, and found the
  ellipse, parabola, and hyperbola in the paths of planets, comets, and
  projectiles.

  In the 17th century Newton and Leibniz created calculus, with its
  techniques for "differentiating" or finding the derivative of functions --
  in geometric terms, finding the tangent of a curve at any given point.
  True, some functions were discontinuous, with no tangent at a gap or an
  isolated point. Some had singularities: abrupt changes in direction at
  which the idea of a tangent becomes meaningless. But these were seen as
  exceptional, and attention was focused on the "well- behaved" functions
  that worked well in modeling nature.

  Beginning in the early 1870s, though, a 50-year crisis transformed
  mathematical thinking. Weierstrass described a function that was continuous
  but nondifferentiable -- no tangent could be described at any point. Cantor
  showed how a simple, repeated procedure could turn a line into a dust of
  scattered points, and Peano generated a convoluted curve that eventually
  touches every point on a plane. These shapes seemed to fall "between" the
  usual categories of one-dimensional lines, two-dimensional planes and
  three-dimensional volumes. Most still saw them as "pathological" cases, but
  here and there they began to find applications.

  In other areas of mathematics, too, strange shapes began to crop up.
  Poincare attempted to analyze the stability of the solar system in the
  1880s and found that the many-body dynamical problem resisted
  traditional methods. Instead, he developed a qualitative approach, a
  "state space" in which each point represented a different planetary
  orbit, and studied what we would now call the topology -- the
  "connectedness" --of whole families of orbits. This approach revealed
  that while many initial motions quickly settled into the familiar
  curves, there were also strange, "chaotic" orbits that never became
  periodic and predict-able.

  Other investigators trying to understand fluctuating, "noisy" phenomena
  -- the flooding of the Nile, price series in economics, the jiggling of
  molecules in Brownian motion in fluids -- found that traditional models
  could not match the data. They had to introduce apparently arbitrary
  scaling features, with spikes in the data becoming rarer as they grew


                                       69

  larger, but never disappearing entirely.

  For many years these developments seemed unrelated, but there were
  tantalizing hints of a common thread. Like the pure mathematicians'
  curves and the chaotic orbital motions, the graphs of irregular time
  series often had the property of self-similarity: a magnified small
  section looked very similar to a large one over a wide range of scales.


  WHO IS THIS GUY, ANYWAY?

  While many pure and applied mathematicians advanced these trends, it is
  Benoit Mandelbrot above all who saw what they had in common and pulled
  the threads together into the new discipline.

  He was born in Warsaw in 1924, and moved to France in 1935. In a time
  when French mathematical training was strongly analytic, he visualized
  problems whenever possible, so that he could attack them in geometric
  terms.  He attended the Ecole Polytechnique, then Caltech, where he
  encountered the tangled motions of fluid turbulence.

  In 1958 he joined IBM, where he began a mathematical analysis of
  electronic "noise" -- and began to perceive a structure in it, a
  hierarchy of fluctuations of all sizes, that could not be explained
  by exiting statistical methods. Through the years that followed, one
  seemingly unrelated problem after another was drawn into the growing
  body of ideas he would come to call fractal geometry.

  As computers gained more graphic capabilities, the skills of his mind's
  eye were reinforced by visualization on display screens and plotters.
  Again and again, fractal models produced results -- series of flood
  heights, or cotton prices -- that experts said looked like "the real
  thing."

  Visualization was extended to the physical world as well. In a
  provocative essay titled "How Long Is the Coast of Britain?" Mandelbrot
  noted that the answer depends on the scale at which one measures: it
  grows longer and longer as one takes into account every bay and inlet,
  every stone, every grain of sand. And he codified the "self-similarity"
  characteristic of many fractal shapes -- the reappearance of geometri-
  cally similar features at all scales.

  First in isolated papers and lectures, then in two editions of his
  seminal book, he argued that many of science's traditional mathematical
  models are ill-suited to natural forms and processes: in fact, that
  many of the "pathological" shapes mathematicians had discovered
  generations before are useful approximations of tree bark and lung
  tissue, clouds and galaxies.

  Mandelbrot was named an IBM Fellow in 1974, and continues to work at
  the IBM Watson Research Center. He has also been a visiting professor
  and guest lecturer at many universities.





                                       70

  A LITTLE CODE

  PERIODICITY LOGIC: The "Mandelbrot Lake" in the center of the M-set
  images is the traditional bane of plotting programs. It sucks up the
  most computer time because it always reaches the iteration limit -- and
  yet the most interesting areas are invariably right at the edge the
  lake.

  Thanks to Mark Peterson for pointing out (well, he more like beat us
  over the head until we paid attention) that the iteration values in the
  middle of Mandelbrot Lake tend to decay to periodic loops (i.e., Z(n+m)
  == Z(n), a fact that is pointed out on pages 58-61 of "The Beauty of
  Fractals"). An intelligent program (like the one he wrote) would check
  for this periodicity once in a while, recognize that iterations caught
  in a loop are going to max out, and bail out early.

  For speed purposes, the current version of the program turns this
  checking algorithm on only if the last pixel generated was in the lake.
  (The checking itself takes a small amount of time, and the pixels on
  the very edge of the lake tend to decay to periodic loops very slowly,
  so this compromise turned out to be the fastest generic answer).

  Try a full M-set plot with a 1000-iteration maximum with any other
  program, and then try it on this one for a pretty dramatic proof of the
  value of periodicity checking.

  You can get a visual display of the periodicity effects if you press
  <O>rbits while plotting. This toggles display of the intermediate
  iterations during the generation process.  It also gives you an idea of
  how much work your poor little PC is going through for you!  If you use
  this toggle, it's best to disable solid-guessing first using <1> or
  <2> because in its second pass, solid-guessing bypasses many of the
  pixel calculations precisely where the orbits are most interesting.

  Mark was also responsible for pointing out that 16-bit integer math was
  good enough for the first few levels of M/J images, where the round-off
  errors stay well within the area covered by a single pixel. FRACTINT
  now uses 16-bit math where applicable, which makes a big difference on
  non-32-bit PCs.


  LIMITATIONS OF INTEGER MATH (and how we now get around it)

  By default, FRACTINT uses 16-bit and/or 32-bit integer math to generate
  nearly all its fractal types. The advantage of integer math is speed: this
  is by far the fastest such plotter that we have ever seen on any PC. The
  disadvantage is an accuracy limit. Integer math represents numbers like
  1.00 as 32-bit integers of the form [1.00 * (2^29)] (approximately
  500,000,000 digits!) for the Mandelbrot and Julia sets. Other integer
  fractal types use a bitshift of 24 rather than 29, so 1.0 is stored
  internally as [1.00 * (2^*24)]. This yields accuracy of better than 8
  significant digits, and works fine... until the initial values of the
  calculations on consecutive pixels differ only in the ninth decimal
  place.



                                       71

  At that point, if Fractint has a floating-point algorithm handy for
  that particular fractal type (and virtually all of the fractal types
  have one these days), it will silently switch over to the
  floating-point algorithm and keep right on going.  Fair warning -
  if you don't have an FPU, the effect is that of a rocket sled hitting
  a wall of jello, and even if you do, the slowdown is noticeable.

  If it has no floating-point algorithm, FRACTINT does the best it can:
  it switches to its minimal drawing mode, with adjacent pixels having
  initial values differing by 1 (really 0.000000002).  Attempts to zoom
  further may result in moving the image around a bit, but won't actually
  zoom.  If you are stuck with an integer algorithm, you can reach minimal
  mode with your fifth consecutive "maximum zoom", each of which covers
  about 0.25% of the previous screen. By then your full-screen image is an
  area less than 1/(10^13)th [~0.0000000000001] the area of the initial
  screen.  (If your image is rotated or stretched very slightly, you can
  run into the wall of jello as early as the fourth consecutive maximum
  zoom.  Rotating or stretching by larger amounts has less impact on how
  soon you run into it.)

  Think of it this way: at minimal drawing mode, your VGA display
  would have to have a surface area of over one million square miles just
  to be able to display the entire M-set using the integer algorithms.
  Using the floating-point algorithms, your display would have to
  be big enough to fit the entire solar system out to the orbit of
  Saturn inside it.  So there's a considerable saving on hardware,
  electricity and desk space involved here.  Also, you don't have to
  take out asteroid insurance.

  32 bit integers also limit the largest number which can be stored.
  This doesn't matter much since numbers outside the supported range
  (which is between -4 and +4) produce a boring single color. If you
  try to zoom-out to reduce the entire Mandelbrot set to a featureless
  speck, or to squeeze it to a pancake, you'll find you can't do so
  in integer math mode.

  THE FRACTINT "FRACTAL ENGINE" ARCHITECTURE

  Several of the authors would never ADMIT this, but FRACTINT has evolved a
  powerful and flexible architecture that makes adding new fractals very
  easy. (They would never admit this because they pride themselves on being
  the sort that mindlessly but happily hacks away at code and "sees if it
  works and doesn't hang the machine".)

  Many fractal calculations work by taking a rectangle in the complex plane,
  and, point by point, calculating a color corresponding to that point.
  Furthermore, the color calculation is often done by iterating a function
  over and over until some bailout condition is met.

  In implementing such a scheme, there are three fractal-specific
  calculations that take place within a framework that is pretty much the
  same for them all.  Rather than copy the same code over and over, we
  created a standard fractal engine that calls three functions that may be
  bolted in temporarily to the engine.  The "bolting in" process uses the C
  language mechanism of variable function pointers.


                                       72


  These three functions are:

       1) a setup function that is run once per image, to do any
       required initialization of variables,

       2) a once-per-pixel function that does whatever
       initialization has to be done to calculate a color for one
       pixel, and

       3) a once-per-orbit-iteration function, which is the
       fundamental fractal algorithm that is repeatedly iterated in
       the fractal calculation.

  The common framework that calls these functions can contain all sorts of
  speedups, tricks, and options that the fractal implementor need not worry
  about.  All that is necessary is to write the three functions in the
  correct way, and BINGO! - all options automatically apply. What makes it
  even easier is that usually one can re-use functions 1) and 2) written for
  other fractals, and therefore only need to write function 3).

  Then it occurred to us that there might be more than one sort of fractal
  engine, so we even allowed THAT to be bolted in. And we created a data
  structure for each fractal that includes pointers to these four functions,
  various prompts, a default region of the complex plane, and various
  miscellaneous bits of information that allow toggling between Julia and
  Mandelbrot or toggling between the various kinds of math used in
  implementation.

  That sounds pretty flexible, but there is one drawback - you have to be a C
  programmer and have a C compiler to make use of it! So we took it a step
  further, and designed a built-in high level compiler, so that you can enter
  the formulas for the various functions in a formula file in a straight-
  forward algebra-like language, and FRACTINT will compile them and bolt them
  in for you!

  There is a terrible down side to this flexibility.  FRACTINT users
  everywhere are going berserk. Fractal-inventing creativity is running
  rampant. Proposals for new fractal types are clogging the mail and the
  telephones.

  All we can say is that non-productivity software has never been so potent,
  and we're sorry, it's our fault!

  FRACTINT was compiled using Microsoft C 5.1/6.0 and Microsoft Assembler
  5.1 using the "Medium" model. Note that the assembler code uses the "C"
  model option added to version 5.1, and must be assembled with the /MX or
  /ML switch to link with the "C" code. Because it has become too large to
  distribute comfortably as a single compressed file, and because many
  downloaders have no intention of ever modifying it, it is now
  distributed as two files: one containing FRACTINT.EXE, auxiliary files
  and this document, and another containing complete source code
  (including a .MAK file and MAKEFRAC.BAT).




                                       73

  APPENDIX A:
                       MATHEMATICS OF THE FRACTAL TYPES

  For functions below, "pixel" is the complex number corresponding to
  the current pixel. "Fn" can be replace by sin, cos, sinh, cosh, exp,
  log or sqr. "^" is the exponential operator, z(n) denotes the nth complex
  orbit value in the sequence z(0), z(1), ..., z(n), z(n+1),...


  Fractal Type(s)             Formula(s) used
  -----------------------     ---------------------------------------------
  Mandel, Julia               z(n+1) = z(n)^2 + C
  Newton, Newtbasin           (roots of) z^n - 1, where n is an integer
  ComplexNewton, ComplexBasin (roots of) z^a - b, where a,b are complex
  plasma                      (see the Plasma section for details)
  Mandelfn, Lambdafn           z(n+1) = Lambda * fn(z(n)) + C (function=sin,
                                cos, sinh, cosh, exp, log, or sqr)
  BarnsleyM1, BarnsleyJ1      z(n+1) = (z(n)-1) * C if Real(z) >= 0
                               else    (z(n)+1) * modulus(C)/C
  BarnsleyM2, BarnsleyJ2      z(n+1) = (z(n)-1) * C if Real(z(n))*Imag(C)
                                       +Real(C)*Imag(z(n)) >= 0
                               else    (z(n)+1) * C
  BarnsleyM3, BarnsleyJ3      z(n+1) = (Real(z(n))^2 - Imag(z(n))^2 - 1)
                                      + i * (2 * Real(z((n)) * Imag(z((n)))
                                        if Real(z(n) > 0
                               else    (Real(z(n))^2 - Imag(z(n))^2 - 1
                                      + lambda * Real(z(n))
                                      + i * (2 * Real(z((n)) * Imag(z((n))
                                             + lambda * Real(z(n))
  Sierpinski                  z(n+1) = (2x, 2y - 1) if y > .5
                               else    (2x - 1, 2y) if x > .5
                               else    (2X, 2y)
  MandelLambda, Lambda        z(n+1) = (C) * (z(n)^2) + C
  MarksMandel, MarksJulia     z(n+1) = (C^(Period-1)) * (z(n)^2) + C
                              ("Period" is a parameter)
  Cmplxmarksmand,Cmplxmarksjul Same as MarksMandel and MarksJulia except
                              period parameter is complex rather than real
  Unity                       (see the Unity section for details)
  ifs, ifs3D                  (see the IFS section for details)
  Mandel4, Julia4             z(n+1) = z(n)^4 + C
  Test                        (as distributed, as simple Mandelbrot fractal)
  Manfn+zsqrd, Julfn+zsqrd    z(n+1) =  fn(z(n)) + z(n)^2 + C
  Manzpower, Julzpower        z(n+1) = z(n)^M + C (M is a parameter)
  Mandel4/Julia4              Special case of manzpower and julzpower (M=4)
  Manzzpwr, Julzzpwr          z(n+1) = z(n)^z(n) + z(n)^M + C
  Manfn+exp, Julfn+exp        z(n+1) = fn(z(n)) + e^(z(n)) + C
  popcorn                     z(n+1) = x(n+1) + i * y(n+1), where
                              x(n+1) = x(n) - 0.05*sin(y(n)) + tan(3*y(n))
                              y(n+1) = y(n) - 0.05*sin(x(n)) + tan(3*x(n))
  popcornjul                  Julia calculation from the popcorn formula.
  Bifurcation                 (see the Bifurcation section for details)
  Bif+sinpi
  Bif=sinpi
  Biflambda



                                       74

  Lorenz, Lorenz3d            Lorenz Attractor - orbits of differential
                              equation:
                              dx/dt = -a*x + a*y
                              dy/dt =  b*x - y   -z*x
                              dz/dt = -c*z + x*y
                              Solution generated by 1st order Taylor series:
                              xnew = x + (-a*x*dt) + (a*y*dt)
                              ynew = y + (b*x*dt) - (y*dt) - (z*x*dt)
                              znew = z + (-c*z*dt) + (x*y*dt)
                              (defaults: dt = .02, a = 5, b = 15, c = 1)
                              (Lorenz3D is the Lorenz Attractor with the
                              addition of 3D perspective transformations
                              as specified by the IFS <E>ditor's
                              transformation option)
  Rossler3d                   Orbit is solution to differential equation:
                              dx/dt = -y -z
                              dy/dt = x + a*y
                              dz/dt = b + x*z - c*z
                              Solution via first order Taylor series:
                              xnew = x - y*dt -   z*dt
                              ynew = y + x*dt + a*y*dt
                              znew = z + b*dt + x*z*dt - c*z*dt
                              Default params are dt=.04, a=.2, b=.2, c=5.7
  Henon                       Orbit generated by:
                              xnew =  1 + y - a*x*x
                              ynew =  b*x
                              The default parameters are a=1.4 and b=.3.
  Pickover                    Orbit generated by:
                              xnew = sin(a*y) - z*cos(b*x)
                              ynew = z*sin(c*x) - cos(d*y)
                              znew = sin(x)
                              Default params: a=2.24, b=.43, c=-.65, d=-2.43
  Gingerbreadman              Orbit generated by:
                              xnew = 1 - y + |x|
                              ynew = x
  Diffusion                   See diffusion type description
  Julibrot                    Same as Mandel and Julia - see type description


  fn(z*z)                     z(0)=pixel; z(n+1) = fn(z(n)*z(n))
  fn*fn                       z(0)=pixel; z(n+1) = fn(n)*fn(n)
  fn*z+z                      z(0)=pixel; z(n+1) = p1*fn(z(n))+p2*z(n)
  fn+fn                       z(0)=pixel; z(n+1) = p1*fn1(z(n))+p2*fn2(z(n))
  sqr(1/fn)                   z(0)=pixel; z(n+1) = (1/fn(z(n))*(1/fn(z(n))
  sqr(fn)                     z(0)=pixel; z(n+1) = fn(z(n))*fn(z(n))
  spider                      c(0)=z(0) = pixel; z(n+1) = z(n)*z(n) + c(n);
                              c(n+1) = c(n)/2 + z(n+1)
  manowar                     c = z1(0) = z(0) = Xcoord + i*Ycoord;
                              z(n+1) = z(n)^2 + z1(n) + c;
                              z1(n+1) = z(n);
  tetrate                     z(0) = c = pixel; z(n+1) = c^z(n)
  kamtorus, kamtorus3d        (See kamtorus type description for details)

  magnetj1,j2,m1,m2           (See type descriptions for details)



                                       75

  INSIDE=bof60|bof61

  Here is an *ATTEMPTED* explanation of what the inside=bof60 and
  inside=bof61 options do. This explanation is hereby dedicated to Adrian
  Mariano, who badgered it out of us! For the *REAL* explanation, see "Beauty
  of Fractals", page 62. Let p(z) be the function that is repeatedly iterated
  to generate a fractal using the escape-time algorithm.  For example, p(z) =
  z^2+c in the case of a Julia set. Then let pk(z) be the result of iterating
  the function p for k iterations. (The "k" should be shown as a
  superscript.) We could also use the notation pkc(z) when the function p has
  a parameter c, as it does in our example.  Now hold your breath and get
  your thinking cap on. Define a(c) = inf{|pck(0)|:k=1,2,3,...}. In English -
  a(c) is the greatest lower bound of the images of zero of as many
  iterations as you like. Put another way, a(c) is the closest to the origin
  any point in the orbit starting with 0 gets. Then the index (c) is the
  value of k (the iteration) when that closest point was achieved.  Since
  there may be more than one, index(c) is the least such. Got it?  Good,
  because the "Beauty of Fractals" explanation of this, is, ahhhh, *TERSE* !
  Now for the punch line. Inside=bof60 colors the lake alternating shades
  according to the level sets of a(c).  Each band represents solid areas of
  the fractal where the closest value of the orbit to the origin is the same.
  Inside=bof61 show domains where index(c) is constant.  That is, areas where
  the iteration when the orbit swooped closest to the origin has the same
  value. Well, folks, that's the best we can do! Improved explanations will
  be accepted for the next edition!

  FINITE ATTRACTORS (inside=attractor)

  Many of Fractint's fractals involve the iteration of functions of
  complex numbers until some "bailout" value is exceeded, then coloring
  the associated pixel according to the number of iterations performed.
  This process identifies which values tend to infinity when iterated,
  and gives us a rough measure of how "quickly" they get there.

  In dynamical terms, we say that "Infinity is an Attractor", as many
  initial values get "attracted" to it when iterated.  The set of all
  points that are attracted to infinity is termed The Basin of Attraction
  of Infinity.  The coloring algorithm used divides this Basin of
  Attraction into many distinct sets, each a single band of one color,
  representing all the points that are "attracted" to Infinity at the
  same "rate".  These sets (bands of color) are termed "Level Sets" - all
  points in such a set are at the same "Level" away from the attractor,
  in terms of numbers of iterations required to exceed the bailout value.

  Thus, Fractint produces colored images of the Level Sets of the Basin
  of Attraction of Infinity, for all fractals that iterate functions of
  Complex numbers, at least.   This discussion so far has served two
  purposes.  First, we now have a sound mathematical definition of what
  Fractint's "bailout" processing generates.  Secondly, we have formally
  introduced the terms Attractor, Basin of Attraction, and Level Set, so
  you should have little trouble following the rest of this section !

  Early versions of Fractint could only handle one Attractor: Infinity.
  Now, however, for certain Julia-type fractals, Fractint can also
  display the Level Sets of Basins of Attraction of Finite Attractors.


                                       76

  This capability is a by-product of the implementation of the MAGNETic
  fractal types, which always have at least one Finite Attractor.

  Most Julia-types that have a "lake" (normally colored blue by default)
  have a Finite Attractor within this lake, and the lake turns out to be,
  quite appropriately, the Basin of Attraction of this Attractor.

  The "inside=attractor" command (invoked from the command line or using
  the "X" menu) instructs Fractint to seek out and identify a possible
  Finite Attractor and, if one is found, attempt to display the Level Sets
  of its Basin of Attraction, in addition to those of the Basin of Attraction
  of Infinity.  In many cases this results in a "lake" with colored "waves"
  in it;  in other cases there may be little change in the lake's
  appearance.

  For a quick demonstration, select a fractal type of LAMBDA, with a
  parameter of 0.5 + 0.5i.  You will obtain an image with a large blue
  lake.  Now set "inside=attractors" with the "X" menu. The Image will be
  re-drawn from scratch, this time with a much more colorful lake.  A Finite
  Attractor lives in the centre of one of the resulting "ripple" patterns in
  the lake - turn the <O>rbits display on if you want to see where it is
  - the orbits of all initial points that are in the lake converge there.

  Fractint tests for the presence of a Finite Attractor by iterating a
  Critical Value of the fractal's function, without periodicity checking,
  before starting to draw the image.  If the iteration limit is exceeded
  before the bailout value, we're looking good.  In this case, we iterate
  again, from where we left off.  If this second pass remains bounded,
  too, it is almost certain that we have a Finite Attractor.  As an added
  bonus, iterating the function for twice the normal maximum time usually
  yields a very good approximation of the value of the Finite Attractor.

  Having thus located a Finite Attractor, we define a small circle around
  it and, after each iteration, as well as testing for the usual bailout
  value being exceeded, we test to see if we've hit the circle. If so, we
  bail out and color our pixels according to the number of iterations
  performed.  Result - a nicely colored-in lake that displays the Level
  Sets of the Basin of Attraction of the Finite Attractor.  Sometimes !

  First exception : This does not work for the lakes of Mandel-types.
  Every point in a Mandel-type is, in effect, a single point plucked from
  one of its related Julia-types.  A Mandel-type's lake has an infinite
  number of points, and thus an infinite number of related Julia-type
  sets, and consequently an infinite number of finite attractors too.  It
  *MAY* be possible to color in such a lake, by determining the attractor
  for EVERY pixel, but this would probably treble (at least) the number
  of iterations needed to draw the image.  Due to this overhead, Finite
  Attractor logic has not been implemented for Mandel-types.

  Secondly, certain Julia-types with lakes may not respond to this
  treatment, depending on the parameter value used.  Eg, the Lambda Set
  for 0.5 + 0.5i responds well; the Lambda Set for 0.0 + 1.0i does not -
  its lake stays blue.  Attractors that consist of single points, or a
  cycle of a finite number of points are ok.  Others are not.  If you're
  into fractal technospeke, the implemented approach fails if the Julia-


                                       77

  type is a Parabolic case, or has Siegel Disks, or has Herman Rings.

  However, all the difficult cases have one thing in common - they all
  have a parameter value that falls exactly on the edge of the related
  Mandel-type's lake.  You can avoid them by intelligent use of the
  Mandel-Julia Space-Bar toggle:  Pick a view of the related Mandel-type
  where the centre of the screen is inside the lake, but not too close to
  its edge, then use the space-bar toggle.  You should obtain a usable
  Julia-type with a lake, if you follow this guideline.

  Thirdly, the initial implementation only works for Julia-types that use
  the "Standard" fractal engine in Fractint.  Fractals with their own
  special algorithms are not affected by Finite Attractor logic, as yet.

  Despite these restrictions, the Finite Attractor logic can produce
  interesting results.  Just bear in mind that it is principally a bonus
  off-shoot from the development of the MAGNETic fractal types, and is
  not specifically tuned for optimal performance for other Julia types.

  (Thanks to Kevin Allen for the above).

  The following trig identities are invaluable for coding fractals that
  use complex-valued transcendental functions.

     e^(x+iy) = (e^x)cos(y) + i(e^x)sin(y)
     sin(x+iy) = sin(x)cosh(y) + icos(x)sinh(y)
     cos(x+iy) = cos(x)cosh(y) - isin(x)sinh(y)
     sinh(x+iy) = sinh(x)cos(y) + icosh(x)sin(y)
     cosh(x+iy) = cosh(x)cos(y) + isinh(x)sin(y)
     ln(x+iy) = (1/2)ln(x*x + y*y) + i(arctan(y/x) + 2kPi)
                                      (k = 0, +-1, +-2, +-....)

                       sin(2x)               sinh(2y)
     tan(x+iy) = ------------------  + i------------------
                 cos(2x) + cosh(2y)     cos(2x) + cosh(2y)

                      sinh(2x)                sin(2y)
     tanh(x+iy) = ------------------ + i------------------
                  cosh(2x) + cos(2y)    cosh(2x) + cos(2y)

         z^z = e^(log(z)*z)
         log(x + iy) = 1/2(log(x*x + y*y) + i(arc_tan(y/x))
         e^(x + iy) = (cosh(x) + sinh(x)) * (cos(y) + isin(y))
                     = e^x * (cos(y) + isin(y))
                     = (e^x * cos(y)) + i(e^x * sin(y))












                                       78

  APPENDIX B
                      STONE SOUP WITH PIXELS: THE AUTHORS

  Once upon a time, somewhere in Eastern Europe, there was a great
  famine. People jealously hoarded whatever food they could find, hiding
  it even from their friends and neighbors. One day a peddler drove his
  wagon into a village, sold a few of his wares, and began asking ques-
  tions as if he planned to stay for the night.

  [No!  No!  It was three Russian Soldiers! - Lee Crocker]
  [Wait!  I heard it was a Wandering Confessor! - Doug Quinn]
  [Well *my* kids have a book that uses Russian Soldiers! - Bert]
  [Look, who's writing this documentation, anyway? - Monte] [Ah, but who
  gets it *last* and gets to upload it? - Bert]

  "There's not a bite to eat in the whole province," he was told. "Better
  keep moving on."

  "Oh, I have everything I need," he said. "In fact, I was thinking of
  making some stone soup to share with all of you." He pulled an iron
  cauldron from his wagon, filled it with water, and built a fire under
  it. Then, with great ceremony, he drew an ordinary-looking stone from a
  velvet bag and dropped it into the water.

  By now, hearing the rumor of food, most of the villagers had come to
  the square or watched from their windows. As the peddler sniffed the
  "broth" and licked his lips in anticipation, hunger began to overcome
  their skepticism.

  "Ahh," the peddler said to himself rather loudly, "I do like a tasty
  stone soup. Of course, stone soup with CABBAGE -- that's hard to beat."

  Soon a villager approached hesitantly, holding a cabbage he'd retrieved
  from its hiding place, and added it to the pot. "Capital!" cried the
  peddler. "You know, I once had stone soup with cabbage and a bit of
  salt beef as well, and it was fit for a king."

  The village butcher managed to find some salt beef...and so it went,
  through potatoes, onions, carrots, mushrooms, and so on, until there
  was indeed a delicious meal for all. The villagers offered the peddler
  a great deal of money for the magic stone, but he refused to sell and
  traveled on the next day. And from that time on, long after the famine
  had ended, they reminisced about the finest soup they'd ever had.

                                  ***

  That's the way FRACTINT has grown, with quite a bit of magic, although
  without the element of deception. (You don't have to deceive programmers
  to make them think that hours of painstaking, often frustrating work is
  fun... they do it to themselves.)

  It wouldn't have happened, of course, without Benoit Mandelbrot and the
  explosion of interest in fractal graphics that has grown from his work
  at IBM. Or without the example of other Mandelplotters for the PC. Or
  without those wizards who first realized you could perform Mandelbrot


                                       79

  calculations using integer math (it wasn't us - we just recognize good
  algorithms when we steal--uhh--see them).  Or those graphics experts
  who hang around the Compuserve PICS forum and keep adding video modes
  to the program.  Or...


  A WORD ABOUT THE AUTHORS

  FRACTINT is the result of a synergy between the main authors, many
  contributors, and published sources.  All four of the main authors have had
  a hand in many aspects of the code.  However, each author has certain areas
  of greater contribution and creativity.  Since there is not room in the
  help screen for the contributions of the main authors, we list these here
  to facilitate those who would like to communicate with us on particular
  subjects.

  Bert Tyler is the original author.  He wrote the "blindingly fast" 386-
  specific 32 bit integer math code and the original video mode logic.  More
  than any of the authors, he has personally touched and massaged the entire
  source. His forte is writing fast 80x86 assembler, his knowledge of a
  variety of video hardware, and his skill at hacking up the code we send
  him!

  Bert has a BA in mathematics from Cornell University.  He has been in
  programming since he got a job at the computer center in his sophomore year
  at college - in other words, he hasn't done an honest day's work in his
  life.  He has been known to pass himself off as a PC expert, a UNIX expert,
  a statistician, and even a financial modeling expert.  He is currently
  masquerading as an independent PC consultant, supporting the PC-to-
  Mainframe communications environment at NIH.  If you sent mail from the
  Internet to an NIH staffer on his 3+Mail system, it was probably Bert's
  code that mangled it during the Internet-to-3+Mail conversion.  He also
  claims to support the MS-Kermit environment at NIH. Fractint is Bert's
  first effort at building a graphics program.

  Tim Wegner contributed the original implementation of palette animation,
  and is responsible for most of the 3D mechanisms.  He provided the main
  outlines of the "StandardFractal" engine and data structures, and is
  accused by his cohorts of being "obsessed with options".  Tim is quite
  proud of having originally integrated the 256 color super VGA modes in
  FRACTINT, especially since he knows almost nothing about it!

  Tim has BA and MA degrees in mathematics from Carleton College and the
  University of California Berkeley.  He worked for 7 years overseas as a
  volunteer, doing things like working with Egyptian villagers building water
  systems. Since returning to the US in 1982, he has written shuttle
  navigation software, a software support environment prototype, and
  supported strategic information planning, all at NASA's Johnson Space
  Center.

  Mark Peterson invented the periodicity detection logic, several original
  fractal types, transcendental function libraries, alternate math
  implementations, the formula compiler, and the "Julibrot" intrinsic 3D
  fractals - in other words, most of the truly original ideas in FRACTINT!



                                       80

  Mark's knowledge of higher mathematics and programming was achieved almost
  entirely through self-study.  Currently he works as a real-time supervisor
  of the electrical transmission system for Connecticut and Massachusetts.
  When not hard at work on programming projects he relaxes with Karate and
  Judo.

  Pieter Branderhorst is a late-comer to the group who likes to distract the
  other authors with enhancements impacting at least 1/2 of the source files
  at once.  His contributions include super solid guessing, image rotation,
  resume, and fast disk caching.

  Pieter left high school to work with computers, back when huge machines had
  64k of core.  He's been happily computing since, mostly programming and
  designing software from comms firmware to database and o/s, and anything
  between, and large scale online transaction processing applications.  He
  has worked as a free-lance computer consultant (whatever that means) since
  1983.


  Accessing the Authors
  ======================================

  Communication between the authors for development of the next version
  of FRACTINT takes place in COMART (Computer Art) Section 15 (Fractals)
  of CompuServe (CIS).  Access to this area is open to any and all
  interested in computer generated fractals.  Stop on by if you have
  any questions or just want to take a peek at what's getting tossed
  into the soup!

  Also, you'll find many GIF image files generated by fellow Fractint
  fans and many fractal programs as well in that forum's data library 15.

  The following authors have agreed to the distribution of their
  addresses. Usenet/Internet/Bitnet/Whatevernet users can reach CIS users
  directly if they know the user ID (i.e., Bert Tyler can be reached as
  [e-mail]).

  Just remember that CIS charges by the minute, so it costs us a little
  bit to read a message -- don't kill us with kindness. And don't send
  all your mail to Bert -- spread it around a little!

  Main authors:

  Bert Tyler              [73477,433] on CIS
  Tyler Software          btyler on BIX
  124 Wooded Lane
  Villanova, PA 19085
  [phone]

  Timothy Wegner          [71320,675] on CIS
  4714 Rockwood           [e-mail] on Internet
  Houston, TX 77004       [e-mail] on Internet
  [phone]




                                       81

  Mark C. Peterson        [70441,3353] on CIS
  253 West St., H
  Plantsville, CT 06479
  [phone] (voice)

  Pieter Branderhorst     [72611,2257] on CIS
  Amthor Computer Consultants
  3915 Bedford Rd.
  Victoria, B.C., Canada V8N 4K6
  [phone]


  Contributing authors (list alphabetically);

  Kevin Allen
  PO Box 335
  Seven Hills
  NSW 2147
  Australia

  Rob Beyer               [71021,2074] on CIS
  23 Briarwood Lane
  Laguna Hills, CA, 92656
  [phone]
  (7-12pm PST & weekends)


  Michael D. Burkey       [e-mail] on Internet
  6600 Crossgate Rd.
  Knoxville, TN 37912

  Lee Daniel Crocker      [73407,2030] on CIS
  1380 Jewett Avenue      lcrocker on BIX
  Pittsburg, CA 94565     ames!pacbell!sactoh0!siva!lee on Usenet
  [phone]

  Monte Davis             [71450,3542] on CIS
  31 Washington St
  Brooklyn, NY 11201
  [phone]

  Richard Finegold        [76701,153] on CIS
  1414 179th Ave NE       [e-mail] on InterNET
  Bellevue, WA 98008      uw-beaver!blake!richg on UseNET
  [phone]

  David Guenther          [70531,3525] on CIS
  50 Rockview Drive
  Irvine, CA 92715

  Michael L. Kaufman      [71610,431] on CIS
  2247 Ridge Ave, #2K     (also accessible via EXEC-PC bbs)
  Evanston, IL, 60201
  [phone]



                                       82

  Adrian Mariano           [e-mail] on INTERNET
  2729 72nd AVE SE
  Mercer Island, WA 98040

  Joe McLain              [75066,1257] on CIS
  McLain Imaging
  2417 Venier
  Costa Mesa, CA 92627
  [phone]

  Bob Montgomery          [73357,3140] on CIS
  (Author of VPIC)
  132 Parsons Road
  Longwood, Fl  32779

  Marc Reinig             [72410,77] on CIS
  3415 Merrill Rd.        [e-mail]!daver!cypress on Usenet
  Aptos, CA. 95003        abu on BIX
  [phone]

  Lee H. Skinner
  P.O. Box 14944
  Albuquerque, NM  87191

  Dean Souleles           [75115,1671] on CIS
  8840 Collett Ave.
  Sepulveda, CA  91343
  [phone]

  Scott Taylor                  [72401,410] on CIS
  1901 South County Road 23E    DGWM18A on Prodigy
  Berthoud, CO 80513
  [phone]

  Paul Varner             [73237,441] on CIS
  PO Box 930
  Shepherdstown, WV 25443
  [phone]

  Phil Wilson             [76247,3145] on CIS
  410 State St., #55
  Brooklyn, NY 11217
  [phone]














                                       83

  APPENDIX C
                               REVISION HISTORY

  Features first appearing in:
  ===========================

  Version 13.0, 5/90

  F1 was made the help key.
    Use F1 for help
    Use F9 for EGA 320x200x16 video mode
    Use CF4 for EGA 640x200x16 mode (if anybody uses that mode)

  Super-Solid-guessing (three or more passes) from Pieter Branderhorst
    (replaces the old solid-guessing mode)

  Boundary Tracing option from David Guenther
    ("fractint passes=btm", or use the new 'x' options screen)

  "outside=nnn" option sets all points not "inside" the fractal
    to color "nnn" (and generates a two-color image).

  'x' option from the main menu brings up a full-screen menu of many
    popular options and toggle switches

  "Speed Key" feature for fractal type selection (either use the
    cursor keys for point-and-shoot, or just start typing the name of
    your favorite fractal type)

  "Attractor" fractals (Henon, Rossler, Pickover, Gingerbread)

  Diffusion fractal type by Adrian Mariano

  "type=formula" formulas from Scott Taylor and Lee H. Skinner.

  "sound=" options for attractor fractals
    Sound=x  plays speaker tones according to the 'x' attractor value
    Sound=y  plays speaker tones according to the 'y' attractor value
    Sound=z  plays speaker tones according to the 'z' attractor value
    (These options are best invoked with the floating-point algorithm
    flag set.)

  "hertz=" option for adjusting the "sound=x/y/z" output.

  Printer support for color printers (printer=color) from Kurt Sowa

    Trident 4000 and Oak Technologies SuperVGA support from John Bridges
    Improved 8514/A support (the zoom-box keeps up with the cursor keys now!)
    Tandy 1000 640x200x16 mode from Brian Corbino (which does not, as yet,
       work with the F1(help) and TAB functions)

  The Julibrot fractal type and the Starmap option now automatically
    verify that they have been selected with a 256-color palette, and
    search for, and use, the appropriate GLASSESn.MAP or ALTERN.MAP
    palette map when invoked.  *You* were supposed to be doing that


                                       84

    manually all along, but *you* probably never read the docs, huh?

  Bug Fixes:

    TAB key now works after R(estore) commands

    PS/2 Model 30 (MCGA) adapters should be able to select 320x200x256
      mode again (we think)

    Everex video adapters should work with the Autodetect modes again
      (we think)

  Version 12.0, 3/90

  New SuperVGA Autodetecting and VESA Video modes (you tell us the
    resolution you want, and we'll figure out how to do it)
  New Full-Screen Entry for most prompting
  New Fractal formula interpreter ('type=formula') - roll your own
    fractals without using a "C" compiler!
  New 'Julibrot' fractal type
  Added floating point option to all remaining fractal types.
  Real (funny glasses) 3D - Now with "real-time" lorenz3D!!
  Non-Destructive <TAB> - Check out what your fractal parameters are
    without stopping the generation of a fractal image
  New Cross-Hair mode for changing individual palette colors (VGA only)
  Zooming beyond the limits of Integer algorithms (with automatic
    switchover to a floating-point algorithm when you zoom in "too far")
  New 'inside=bof60', 'inside=bof61' ("Beauty of Fractals, Page nn") options
  New starmap ('a' - for astrology? astronomy?) transformation option
  Restrictions on the options available when using Expanded Memory
    "Disk/RAM" video mode have been removed
  And a lot of other nice little clean-up features that we've already
    forgotten that we've added...
  Added capability to create 3D projection images (just barely) for people
    with 2 or 4 color video boards.

  Version 11.0, 1/90

  More fractal types
     mandelsinh/lambdasinh        mandelcosh/lambdacosh
     mansinzsqrd/julsinzsqrd      mansinexp/julsinexp
     manzzprw/julzzpwr            manzpower/julzpower
     lorenz (from Rob Beyer)      lorenz3d
     complexnewton                complexbasin
     popcorn

  Most fractal types given an integer and a floating point algorithm.
  "Float=yes" option now determines whether integer or floating-point
       algorithms are used for most fractal types
  "F" command toggles the use of floating-point algorithms, flagged in
       the <Tab> status display
  8/16/32/../256-Way decomposition option (from Richard Finegold)
  "Biomorph=", "bailout=", "symmetry="  and "askvideo=" options
  "T(ransform)" option in the IFS editor lets you select 3D options (used
       with the Lorenz3D fractal type)


                                       85

  The "T(ype)" command uses a new "Point-and-Shoot" method of selecting
       fractal types rather than prompting you for a type name
  Bug fixes to continuous-potential algorithm on integer fractals, GIF
       encoder, and IFS editor

  Version 10.0, 11/89

  Barnsley IFS type (Rob Beyer)
  Barnsley IFS3D type
  MandelSine/Cos/Exp type
  MandelLambda/MarksLambda/Unity type
  BarnsleyM1/J1/M2/J2/M3/J3 type
  Mandel4/Julia4 type
  Sierpinski gasket type
  Demm/Demj and bifurcation types (Phil Wilson), "test" is "mandel"
    again
  <I>nversion command for most fractal types
  <Q>uaternary decomposition toggle and "DECOMP=" argument
  <E>ditor for Barnsley IFS parameters
  Command-line options for 3D parameters
  Spherical 3D calculations 5x faster
  3D now clips properly to screen edges and works at extreme
    perspective
  "RSEED=" argument for reproducible plasma clouds
  Faster plasma clouds (by 40% on a 386)
  Sensitivity to "continuous potential" algorithm for all types except
    plasma and IFS
  Palette-map <S>ave and Restore (<M>) commands
  <L>ogarithmic and <N>ormal palette-mapping commands and arguments
  Maxiter increased to 32,000 to support log palette maps
   .MAP and .IFS files can now reside anywhere along the DOS path
  Direct-video support for Hercules adapters (Dean Souleles)
  Tandy 1000 160x200x16 mode (Tom Price)
  320x400x256 register-compatible-VGA "tweaked" mode
  ATI VGA Wonder 1024x768x16 direct-video mode (Mark Peterson)
  1024x768x16 direct-video mode for all supported chipsets
  Tseng 640x400x256 mode
  "Roll-your-own" video mode 19
  New video-table "hot-keys" eliminate need for enhanced keyboard to
    access later entries


  Version 9.3, 8/89

  <P>rint command and "PRINTER=" argument (Matt Saucier)
  8514/A video modes (Kyle Powell)
  SSTOOLS.INI sensitivity and '@THISFILE' argument
  Continuous-potential algorithm for Mandelbrot/Julia sets
  Light source 3D option for all fractal types
  "Distance estimator" M/J method (Phil Wilson) implemented as "test"
    type
  LambdaCosine and LambdaExponent types
  Color cycling mode for 640x350x16 EGA adapters
  Plasma clouds for 16-color and 4-color video modes
  Improved TARGA support (Joe McLain)


                                       86

  CGA modes now use direct-video read/writes
  Tandy 1000 320x200x16 and 640x200x4 modes (Tom Price)
  TRIDENT chip-set super-VGA video modes (Lew Ramsey)
  Direct-access video modes for TRIDENT, Chips & Technologies, and ATI
    VGA WONDER adapters (John Bridges)... and, unlike version 9.1, they
    WORK in version 9.3!)
  "zoom-out" (<Ctrl><Enter>) command
  <D>os command for shelling out
  2/4/16-color Disk/RAM video mode capability and 2-color video modes
    supporting full-page printer graphics
  "INSIDE=-1" option (treated dynamically as "INSIDE=maxiter")
  Improved <H>elp and sound routines (even a "SOUND=off" argument)
  Turbo-C and TASM compatibility (really!  Would we lie to you?)


  Version 8.1, 6/89

  <3>D restore-from-disk and 3D <O>verlay commands, "3D=" argument
  Fast Newton algorithm including inversion option (Lee Crocker)
  16-bit Mandelbrot/Julia logic for 386-class speed with non-386 PCs on
    "large" images (Mark Peterson)
  Restore now loads .GIF files (as plasma clouds)
  TARGA video modes and color-map file options (Joe McLain)
  30 new color-cycling palette options (<Shft><F1> to <Alt><F10>)
  "Disk-video, RAM-video, EMS-video" modes
  Lambda sets now use integer math (with 80386 speedups)
  "WARN=yes" argument to prevent over-writing old .GIF files


  Version 7.0, 4/89

  Restore from disk (from prior save-to-disk using v. 7.0 or later)
  New types: Newton, Lambda, Mandelfp, Juliafp, Plasma, Lambdasine
  Many new color-cycling options (for VGA adapters only)
  New periodicity logic (Mark Peterson)
  Initial displays recognize (and use) symmetry
  Solid-guessing option (now the default)
  Context-sensitive <H>elp
  Customizable video mode configuration file (FRACTINT.CFG)
  "Batch mode" option
  Improved super-VGA support (with direct video read/writes)
  Non-standard 360 x 480 x 256 color mode on a STANDARD IBM VGA!


  Version 6.0, 2/89

  32-bit integer math emulated for non-386 processors; FRACT386 renamed
    FRACTINT
  More video modes


  Version 5.1, 1/89

  Save to disk
  New! Improved! (and Incompatible!) optional arguments format


                                       87

  "Correct" initial image aspect ratio
  More video modes

  Version 4.0, 12/88

  Mouse support (Mike Kaufman)
  Dynamic iteration limits
  Color cycling
  Dual-pass mode
  More video modes, including "tweaked" modes for IBM VGA and register-
    compatible adapters


  Version 3.1, 11/88

  Julia sets


  Version 2.1, 10/23/88 (the "debut" on CIS)

  Video table
  CPU type detector


  Version 2.0, 10/10/88

  Zoom and pan


  Version 1.0, 9/88

  The original, blindingly fast, 386-specific 32-bit integer algorithm


  APPENDIX D

                                 BIBLIOGRAPHY

  BARNSLEY, Michael: "Fractals Everywhere", Academic Press, 1988.

  DEWDNEY, A. K., "Computer Recreations" columns in "Scientific
    American" -- 8/85, 7/87, 11/87, 12/88, 7/89.

  FEDER, Jens: "Fractals", Plenum, 1988. Quite technical, with good coverage
      of applications in fluid percolation, game theory, and other areas.

  GLEICK, James: "Chaos: Making a New Science", Viking Press, 1987.
      The best non-technical account of the revolution in our
      understanding of dynamical systems and its connections with fractal
      geometry.







                                       88

  MANDELBROT, Benoit: "The Fractal Geometry of Nature", W. H. Freeman &
    Co., 1982.
      An even more revised and expanded version of the 1977 work. A rich
      and sometimes confusing stew of formal and informal mathematics,
      the prehistory of fractal geometry, and everything else. Best taken
      in small doses.

  MANDELBROT, Benoit: "Fractals: Form, Chance, and Dimension", W. H.
    Freeman & Co., 1977
      A much revised translation of "Les objets fractals: forme, hasard,
      et dimension," Flammarion, 1975.

  PEITGEN, Heinz-Otto & RICHTER, Peter: "The Beauty of Fractals,"
    Springer-Verlag, 1986.
      THE coffee-table book of fractal images, knowledgeable on computer
      graphics as well as the mathematics they portray.

  PEITGEN, Heinz-Otto & SAUPE, Ditmar: "The Science of Fractal Images,"
    Springer-Verlag, 1988.
      A fantastic work, with a few nice pictures, but mostly filled
      with *equations*!!!




  APPENDIX E

                            OTHER FRACTAL PROGRAMS


  (This section is new, and pathetically small because we added it at the
  last minute.  Please help us out, here...)


  FDESIGN, by Doug Nelson (CIS ID 70431,3374) - a freeware IFS fractal
    generator available from Compuserve in COMART Lib 15, and probably
    on your local BBS.  This program requires a VGA adapter and a Microsoft-
    compatible mouse, but it generates IFS fractals in a *much* more
    intuitive fashion than Fractint.  It can also (beginning with version
    3.0) save its IFS formulas in Fractint-style .IFS files.


  APPENDIX F

                     VERSION 13 TO VERSION 14 TYPE MAPPING

  A number of types in version 13 and earlier have been generalized in
  version 14. We have added a "backward compatibility" hook that (hopefully)
  automatically translates these to the new form when the old files are read.
  Files may be converted via:

     FRACTINT OLDFILE.FRA SAVENAME=NEWFILE.GIF BATCH=YES

  In a few cases the biomorph flag was incorrectly set in older files.  In
  that case, add "biomorph=no" to the command line.


                                       89


  This procedure can also be used to convert any *.fra file to the new GIF89a
  spec, which now allows storage of fractal information.

  TYPES CHANGED FROM VERSION 13 -


  V13 NAME                V14 NAME + PARAMETERS
  --------                --------------------------------------
  LOGMAP=YES              LOGMAP=OLD          for identical Logmap type

  DEMJ                    JULIA DISTEST=nnn

  DEMM                    MANDEL DISTEST=nnn

                          Note: DISTEST also available on many other fractals

  MANSINEXP               MANFN+EXP FUNCTION=SIN

                          Note: New functions for this type are
                                cos sinh cosh exp log sqr

  JULSINEXP               JULFN+EXP FUNCTION=SIN

                          Note: New functions for this type are
                                cos sinh cosh exp log sqr

  MANSINZSQRD             MANFN+ZSQRD FUNCTION=SQR/SIN

                          Note: New functions for this type are
                                cos sinh cosh exp log sqr

  JULSINZSQRD             JULFN+ZSQRD FUNCTION=SQR/SIN

                          Note: New functions for this type are
                                cos sinh cosh exp log sqr

  LAMBDACOS               LAMBDAFN FUNCTION=COS

  LAMBDACOSH              LAMBDAFN FUNCTION=COSH

  LAMBDAEXP               LAMBDAFN FUNCTION=EXP

  LAMBDASINE              LAMBDAFN FUNCTION=SIN

  LAMBDASINH              LAMBDAFN FUNCTION=SINH

                          Note: New functions for this type are
                                log sqr

  MANDELCOS               MANDELFN FUNCTION=COS

  MANDELCOSH              MANDELFN FUNCTION=COSH

  MANDELEXP               MANDELFN FUNCTION=EXP


                                       90


  MANDELSINE              MANDELFN FUNCTION=SIN

  MANDELSINH              MANDELFN FUNCTION=SINH

                          Note: New functions for this type are
                                log sqr

  MANDELLAMBDA            MANDELLAMBDA INITORBIT=PIXEL

  POPCORN SYMMETRY=NONE   POPCORNJUL

  -------------------------------------------------------------
  Formulas from FRACTINT.FRM in version 13

  MANDELGLASS             MANDELLAMBDA INITORBIT=.5/0

  INVMANDEL               V13 divide bug may cause some image differences.

  NEWTON4                 V13 divide bug may cause some image differences.

  SPIDER                  V13 divide bug may cause some image differences.

  MANDELSINE              MANDELFN FUNCTION=SIN BAILOUT=50

  MANDELCOSINE            MANDELFN FUNCTION=COS BAILOUT=50

  MANDELHYPSINE           MANDELFN FUNCTION=SINH BAILOUT=50

  MANDELHYPCOSINE         MANDELFN FUNCTION=COSH BAILOUT=50

  SCOTTSIN PARAMS=nnn     FN+FN FUNCTION=SIN/SQR BAILOUT=nnn+3

  SCOTTSINH PARAMS=nnn    FN+FN FUNCTION=SINH/SQR BAILOUT=nnn+3

  SCOTTCOS PARAMS=nnn     FN+FN FUNCTION=COS/SQR BAILOUT=nnn+3

  SCOTTCOSH PARAMS=nnn    FN+FN FUNCTION=COSH/SQR BAILOUT=nnn+3

  SCOTTLPC PARAMS=nnn     FN+FN FUNCTION=LOG/COS BAILOUT=nnn+3

  SCOTTLPS PARAMS=nnn     FN+FN FUNCTION=LOG/SIN BAILOUT=nnn+3

                          Note: New functions for this type are
                          sin/sin sin/cos sin/sinh sin/cosh sin/exp
                          cos/cos cos/sinh cos/cosh cos/exp
                          sinh/sinh sinh/cosh sinh/exp sinh/log
                          cosh/cosh cosh/exp cosh/log
                          exp/exp exp/log exp/sqr log/log log/sqr sqr/sqr

  SCOTTSZSA PARAMS=nnn    FN(Z*Z) FUNCTION=SIN BAILOUT=nnn+3

  SCOTTCZSA PARAMS=nnn    FN(Z*Z) FUNCTION=COS BAILOUT=nnn+3

                          Note: New functions for this type are


                                       91

                          sinh cosh exp log sqr

  SCOTTZSZZ PARAMS=nnn    FN*Z+Z FUNCTION=SIN BAILOUT=nnn+3

  SCOTTZCZZ PARAMS=nnn    FN*Z+Z FUNCTION=COS BAILOUT=nnn+3

                          Note: New functions for this type are
                          sinh cosh exp log sqr

  SCOTTSZSB PARAMS=nnn    FN*FN FUNCTION=SIN/SIN BAILOUT=nnn+3

  SCOTTCZSB PARAMS=nnn    FN*FN FUNCTION=COS/COS BAILOUT=nnn+3

  SCOTTLTS PARAMS=nnn     FN*FN FUNCTION=LOG/SIN BAILOUT=nnn+3

  SCOTTLTC PARAMS=nnn     FN*FN FUNCTION=LOG/COS BAILOUT=nnn+3

                          Note: New functions for this type are
                          sin/cos sin/sinh sin/cosh sin/exp sin/sqr
                          cos/sinh cos/cosh cos/exp cos/sqr
                          sinh/sinh sinh/cosh sinh/exp sinh/log sinh/sqr
                          cosh/cosh cosh/exp cosh/log cosh/sqr
                          exp/exp exp/log exp/sqr log/log log/sqr sqr/sqr

  SCOTTSIC PARAMS=nnn     SQR(1/FN) FUNCTION=COS BAILOUT=nnn+3

  SCOTTSIS PARAMS=nnn     SQR(1/FN) FUNCTION=SIN BAILOUT=nnn+3

  TETRATE PARAMS=nnn      TETRATE BAILOUT=nnn+3

                          Note: New function type sqr(1/fn) with
                                sin cos sinh cosh exp log sqr

                          Note: New function type sqr(fn) with
                                sin cos sinh cosh exp log sqr






















                                       92